Feature/add export command

src/Dataverse.ConfigurationMigrationTool/Console.Tests/CodeCoverage.runsettings

@@ -6,7 +6,7 @@
 				<Configuration>
 					<Format>cobertura,opencover</Format>
 					<Exclude>[*]Dataverse.ConfigurationMigrationTool.Console.Services.Dataverse.Connection.*,[*]Dataverse.ConfigurationMigrationTool.Console.Services.Dataverse.Configuration.*</Exclude>
-					<ExcludeByFile>**/Program.cs,</ExcludeByFile>
+					<ExcludeByFile>**/Program.cs,**/IServiceCollectionExtensions.cs</ExcludeByFile>
 					<SkipAutoProps>true</SkipAutoProps>
 				</Configuration>
 			</DataCollector>

src/Dataverse.ConfigurationMigrationTool/Console.Tests/FakeBuilders/FakeEntityMetadataBuilder.cs

@@ -35,6 +35,8 @@ public FakeEntityMetadataBuilder AddRelationship(string SchemaName, string Targe
         {
             Entity1LogicalName = EntityName,
             Entity2LogicalName = TargetEntity,
+            Entity1IntersectAttribute = $"{EntityName}id",
+            Entity2IntersectAttribute = $"{TargetEntity}id",
             IntersectEntityName = SchemaName,
             SchemaName = SchemaName
         };

src/Dataverse.ConfigurationMigrationTool/Console.Tests/FakeDatasets.cs

@@ -1,4 +1,4 @@
-using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Model;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
 
 namespace Dataverse.ConfigurationMigrationTool.Console.Tests;
 internal static class FakeDatasets

src/Dataverse.ConfigurationMigrationTool/Console.Tests/FakeSchemas.cs

@@ -1,4 +1,4 @@
-using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Model;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
 
 namespace Dataverse.ConfigurationMigrationTool.Console.Tests;
 internal static class FakeSchemas

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Export/Commands/ExportCommandTests.cs

@@ -0,0 +1,77 @@
+using Dataverse.ConfigurationMigrationTool.Console.Features.Export;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Export.Commands;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NSubstitute;
+using Shouldly;
+
+namespace Dataverse.ConfigurationMigrationTool.Console.Tests.Features.Export.Commands;
+public class ExportCommandTests
+{
+    private readonly ILogger<ExportCommand> _logger;
+    private readonly ExportCommandOption _options = new ExportCommandOption();
+    private readonly IOptions<ExportCommandOption> _optionsWrapper;
+    private readonly IValidator<DataSchema> _schemaValidator;
+    private readonly IFileDataService _fileDataService;
+    private readonly IDataExportService _dataExportService;
+    private readonly ExportCommand _exportCommand;
+    public ExportCommandTests()
+    {
+        _logger = Substitute.For<ILogger<ExportCommand>>();
+        _optionsWrapper = Substitute.For<IOptions<ExportCommandOption>>();
+        _optionsWrapper.Value.Returns(_options);
+        _schemaValidator = Substitute.For<IValidator<DataSchema>>();
+        _fileDataService = Substitute.For<IFileDataService>();
+        _dataExportService = Substitute.For<IDataExportService>(); ;
+        _exportCommand = new ExportCommand(_logger, _optionsWrapper, _schemaValidator, _fileDataService, _dataExportService);
+    }
+
+    [Fact]
+    public async Task GivenACommand_WhenItExecutesWithASchema_ThenItShouldExportData()
+    {
+        // Arrange
+        _options.schema = "schema.json";
+        _options.output = "output.json";
+
+        var schema = new DataSchema();
+        _fileDataService.ReadAsync<DataSchema>(_options.schema).Returns(Task.FromResult(schema));
+        var validationResult = new ValidationResult();
+        _schemaValidator.Validate(schema).Returns(Task.FromResult(validationResult));
+        var entities = new List<EntityImport>
+        {
+            new EntityImport { Name = "TestEntity", Displayname = "Test Entity" }
+        };
+        _dataExportService.ExportEntitiesFromSchema(schema).Returns(Task.FromResult(entities.AsEnumerable()));
+        // Act
+        await _exportCommand.Execute();
+        // Assert
+        await _fileDataService.Received(1).WriteAsync(Arg.Is<Entities>(e => e.Entity.Count == 1), _options.output);
+    }
+    [Fact]
+    public async Task GivenACommand_WhenItExecutesWithAnInvalidSchema_ThenItShouldThrowError()
+    {
+        // Arrange
+        _options.schema = "schema.json";
+        _options.output = "output.json";
+
+        var schema = new DataSchema();
+        _fileDataService.ReadAsync<DataSchema>(_options.schema).Returns(Task.FromResult(schema));
+        var validationResult = new ValidationResult()
+        {
+            Failures = [new("Test", "property failure")]
+        };
+        _schemaValidator.Validate(schema).Returns(Task.FromResult(validationResult));
+        var entities = new List<EntityImport>
+        {
+            new EntityImport { Name = "TestEntity", Displayname = "Test Entity" }
+        };
+        _dataExportService.ExportEntitiesFromSchema(schema).Returns(Task.FromResult(entities.AsEnumerable()));
+        // Act
+        var ex = await _exportCommand.Execute().ShouldThrowAsync<Exception>();
+        // Assert
+        ex.Message.ShouldBe("Provided Schema was not valid.");
+    }
+
+}

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Export/DataExportServiceTests.cs

@@ -0,0 +1,92 @@
+using Dataverse.ConfigurationMigrationTool.Console.Features.Export;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using Shouldly;
+using Record = Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain.Record;
+
+namespace Dataverse.ConfigurationMigrationTool.Console.Tests.Features.Export;
+public class DataExportServiceTests
+{
+    private readonly ILogger<DataExportService> _logger;
+    private readonly IMetadataService _metadataService;
+    private readonly IDomainService _domainService;
+    private readonly DataExportService _dataExportService;
+
+    public DataExportServiceTests()
+    {
+        _logger = Substitute.For<ILogger<DataExportService>>();
+        _metadataService = Substitute.For<IMetadataService>();
+        _domainService = Substitute.For<IDomainService>();
+        _dataExportService = new DataExportService(_logger, _metadataService, _domainService);
+    }
+    [Fact]
+    public async Task GivenADataExportService_WhenItExportsDataFromSchema_ThenItShouldUseDomainServiceProperly()
+    {
+        //Arrange
+
+        var schema = FakeSchemas.Contact;
+        var metadata = FakeMetadata.Contact;
+        _metadataService.GetEntity(metadata.LogicalName).Returns(metadata);
+
+        var records = new List<Record>
+        {
+            new()
+            {
+                Id = Guid.NewGuid(),
+                Field = [new(){
+                    Name = "firstname",
+                    Value = "John"
+                },
+                new(){
+                    Name = "lastname",
+                    Value = "Doe"
+                }],
+            },
+             new()
+            {
+                  Id = Guid.NewGuid(),
+                Field = [new(){
+                    Name = "firstname",
+                    Value = "Jane"
+                },
+                new(){
+                    Name = "lastname",
+                    Value = "Dane"
+                }],
+            }
+        };
+        var rels = new List<M2mrelationship>
+        {
+            new()
+            {
+                M2mrelationshipname = "contact_opportunities",
+                Sourceid = Guid.NewGuid(),
+                Targetentityname = "opportunity",
+                Targetentitynameidfield = "opportunityid",
+                Targetids = new Targetids
+                {
+                    Targetid = [Guid.NewGuid(), Guid.NewGuid()]
+                }
+            }
+        };
+
+        _domainService.GetRecords(schema).Returns(records);
+        _domainService.GetM2mRelationships(metadata.ManyToManyRelationships.First())
+            .Returns(rels);
+
+        //Act
+        var result = await _dataExportService.ExportEntitiesFromSchema(new DataSchema
+        {
+            Entity = [schema]
+        });
+        //Assert
+        var entityImport = result.Single();
+        entityImport.Name.ShouldBe(schema.Name);
+        entityImport.Displayname.ShouldBe(schema.Displayname);
+        entityImport.Records.Record.ShouldBe(records);
+        entityImport.M2mrelationships.M2mrelationship.ShouldBe(rels, true);
+    }
+
+}

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Export/Mappers/DataverseRecordToRecordMapperTests.cs

@@ -0,0 +1,35 @@
+using Dataverse.ConfigurationMigrationTool.Console.Features.Export.Mappers;
+using Microsoft.Xrm.Sdk;
+using Shouldly;
+
+namespace Dataverse.ConfigurationMigrationTool.Console.Tests.Features.Export.Mappers;
+public class DataverseRecordToRecordMapperTests
+{
+    private readonly DataverseRecordToRecordMapper _mapper = new DataverseRecordToRecordMapper();
+    [Fact]
+    public void GivenAnEntity_WhenItIsMappedToARecord_ThenItTheRecordShouldBeProperplyCreated()
+    {
+        //Arrange
+        var Schema = FakeSchemas.Account;
+        var Entity = new Entity("account")
+        {
+            Id = Guid.NewGuid(),
+            ["name"] = "Test Account",
+            ["primarycontactid"] = new EntityReference("contact", Guid.NewGuid())
+        };
+        //Act
+        var record = _mapper.Map((Schema, Entity));
+        //Assert
+        record.Id.ShouldBe(Entity.Id);
+        record.Field.ForEach(field =>
+        {
+            field.ShouldNotBeNull();
+            Entity.Attributes.Keys.ShouldContain(field.Name);
+        });
+        record.Field.First(f => f.Name == "name").Value.ShouldBe("Test Account");
+        var lookupField = record.Field.First(f => f.Name == "primarycontactid");
+        lookupField.Value.ShouldBe(Entity.GetAttributeValue<EntityReference>("primarycontactid").Id.ToString());
+        lookupField.Lookupentity.ShouldBe("contact");
+        lookupField.Lookupentityname.ShouldBeNull();
+    }
+}

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Export/Mappers/EntityFieldValueToFieldMapperTests.cs

@@ -0,0 +1,83 @@
+using Dataverse.ConfigurationMigrationTool.Console.Features.Export.Mappers;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
+using Microsoft.Xrm.Sdk;
+using Shouldly;
+using System.Web;
+
+namespace Dataverse.ConfigurationMigrationTool.Console.Tests.Features.Export.Mappers;
+public class EntityFieldValueToFieldMapperTests
+{
+    private readonly EntityFieldValueToFieldMapper _mapper = new EntityFieldValueToFieldMapper();
+    private static readonly DateTime CurrentDate = DateTime.UtcNow;
+    private static readonly Guid RandomGuid = Guid.NewGuid();
+    public static TheoryData<FieldSchema, object, Field> TestData => new TheoryData<FieldSchema, object, Field>
+    {
+        {
+            new FieldSchema { Name = "testField" },
+            null,
+            null
+        },
+        {
+            new FieldSchema { Name = "testLookupField" },
+            new EntityReference("testEntity", RandomGuid),
+            new Field { Name = "testLookupField", Lookupentity = "testEntity", Value = RandomGuid.ToString() }
+        },
+        {
+            new FieldSchema { Name = "testOptionSetField" },
+            new OptionSetValue(1),
+            new Field { Name = "testOptionSetField", Value = "1" }
+        },
+        {
+            new FieldSchema { Name = "testBooleanField" },
+            true,
+            new Field { Name = "testBooleanField", Value = "True" }
+        },
+        {
+            new FieldSchema { Name = "testDateTimeField" },
+            CurrentDate,
+            new Field { Name = "testDateTimeField", Value = CurrentDate.ToString("o") }
+        },
+        {
+            new FieldSchema { Name = "testGuidField" },
+            RandomGuid,
+            new Field { Name = "testGuidField", Value = RandomGuid.ToString() }
+        },
+        {
+            new FieldSchema { Name = "testMoneyField" },
+            new Money(100.50m),
+            new Field { Name = "testMoneyField", Value = "100.50" }
+        },
+        {
+            new FieldSchema { Name = "testDecimalField" },
+            123.45m,
+            new Field { Name = "testDecimalField", Value = "123.45" }
+        },
+        {
+            new FieldSchema { Name = "testDoubleField" },
+            123.456789,
+            new Field { Name = "testDoubleField", Value = "123.456789" }
+        },
+        {
+            new FieldSchema { Name = "testStringField" },
+            "<>Root<>''/",
+            new Field { Name = "testStringField", Value = HttpUtility.HtmlEncode("<>Root<>''/") }
+        }
+    };
+
+    [Theory]
+    [MemberData(nameof(TestData))]
+    public void GivenAnAttributeValue_WhenItIsMappedToAField_ThenFieldShouldBeCreatedProperly(FieldSchema schema, object value, Field expected)
+    {
+        // Act
+        var result = _mapper.Map((schema, value));
+        // Assert
+        if (expected == null)
+        {
+            result.ShouldBeNull();
+        }
+        else
+        {
+            result.ShouldBeEquivalentTo(expected);
+        }
+    }
+}

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Import/Commands/ImportCommandsTest.cs

@@ -2,6 +2,7 @@
 using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Commands;
 using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Model;
 using Dataverse.ConfigurationMigrationTool.Console.Features.Shared;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
 using Dataverse.ConfigurationMigrationTool.Console.Tests.Extensions;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -13,7 +14,7 @@ public class ImportCommandsTest
 {
     private readonly ILogger<ImportCommands> _logger;
     private readonly IImportDataProvider _importDataProvider;
-    private readonly IValidator<ImportSchema> _schemaValidator;
+    private readonly IValidator<DataSchema> _schemaValidator;
     private readonly IImportTaskProcessorService _importDataService;
     private readonly ImportCommands _importCommands;
     const string DataFilePath = "data.json";
@@ -28,7 +29,7 @@ public ImportCommandsTest()
     {
         _logger = Substitute.For<ILogger<ImportCommands>>();
         _importDataProvider = Substitute.For<IImportDataProvider>();
-        _schemaValidator = Substitute.For<IValidator<ImportSchema>>();
+        _schemaValidator = Substitute.For<IValidator<DataSchema>>();
         _importDataService = Substitute.For<IImportTaskProcessorService>();
         var options = Substitute.For<IOptions<ImportCommandOptions>>();
         options.Value.Returns(_options);
@@ -43,7 +44,7 @@ public ImportCommandsTest()
     public async Task GivenDataToImportWithSchema_WhenTheCommandExecutes_ThenItShouldProcessImportsAccordingly()
     {
         //Arrange
-        var importSchema = new ImportSchema
+        var importSchema = new DataSchema
         {
             Entity = new()
             {
@@ -84,7 +85,7 @@ public async Task GivenDataToImportWithSchema_WhenTheCommandExecutes_ThenItShoul
     public async Task GivenDataToImportWithSchema_WhenTheCommandExecutesAndFails_ThenItShouldThrowAnError()
     {
         //Arrange
-        var importSchema = new ImportSchema
+        var importSchema = new DataSchema
         {
             Entity = new()
             {
@@ -122,7 +123,7 @@ public async Task GivenDataToImportWithSchema_WhenTheCommandExecutesAndFails_The
     public async Task GivenAnInvalidSchema_WhenTheCommandExecutes_ThenItShouldFailAndLogIssues()
     {
         //Arrange
-        var importSchema = new ImportSchema
+        var importSchema = new DataSchema
         {
             Entity = new()
             {

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Import/ImportTaskProcessorServiceTests.cs

@@ -3,6 +3,7 @@
 using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Model;
 using Dataverse.ConfigurationMigrationTool.Console.Features.Import.ValueConverters;
 using Dataverse.ConfigurationMigrationTool.Console.Features.Shared;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
 using Dataverse.ConfigurationMigrationTool.Console.Services.Dataverse.Connection;
 using Dataverse.ConfigurationMigrationTool.Console.Tests.Extensions;
 using Dataverse.ConfigurationMigrationTool.Console.Tests.FakeBuilders;

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Import/Mappers/FieldSchemaToAttributeTypeMapperTests.cs

@@ -1,5 +1,5 @@
 using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Mappers;
-using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Model;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
 using Microsoft.Xrm.Sdk.Metadata;
 using Shouldly;
 

src/Dataverse.ConfigurationMigrationTool/Console.Tests/Features/Import/ValueConverters/DataverseValueConverterTests.cs

@@ -1,5 +1,5 @@
-using Dataverse.ConfigurationMigrationTool.Console.Features.Import.Model;
-using Dataverse.ConfigurationMigrationTool.Console.Features.Import.ValueConverters;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Import.ValueConverters;
+using Dataverse.ConfigurationMigrationTool.Console.Features.Shared.Domain;
 using Dataverse.ConfigurationMigrationTool.Console.Tests.FakeBuilders;
 using Microsoft.Xrm.Sdk;
 using Microsoft.Xrm.Sdk.Metadata;