5812535745

Committed 09 Aug 2023 06:06PM UTC coverage: 40.495% (-0.002%) from 40.497%

Build # 5812535745

Build Type

push

github

Committed by

pwelter34

Commit Message

fix tests

Run Details

794 of 2421 branches covered (32.8%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

2431 of 5543 relevant lines covered (43.86%)

108.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/test/FluentCommand.SqlServer.Tests/ImportProcessorTests.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

using FluentAssertions;

using FluentCommand.Import;

using Xunit;

namespace FluentCommand.SqlServer.Tests;

public class ImportProcessorTests : ImportProcessor
{
    public ImportProcessorTests()
        : base(null, Activator.CreateInstance)
    {
    }

    [Fact]
    public void CreateTableTest()
    {
        var userDefinition = CreateDefinition();
        userDefinition.Should().NotBeNull();
        userDefinition.Name.Should().Be("User");
        userDefinition.Fields.Count.Should().Be(5);

        var importData = CreateImportData();
        importData.Should().NotBeNull();

        var importContext = new ImportProcessContext(userDefinition, importData, "test@email.com", Activator.CreateInstance);
        importContext.Should().NotBeNull();
        importContext.Definition.Should().NotBeNull();
        importContext.ImportData.Should().NotBeNull();

        var dataTable = this.CreateTable(importContext);
        dataTable.Should().NotBeNull();
        dataTable.Columns.Count.Should().Be(5);
        dataTable.Columns[0].ColumnName.Should().Be("EmailAddress");
        dataTable.Columns[0].DataType.Should().Be<string>();
        dataTable.Columns[1].ColumnName.Should().Be("FirstName");
        dataTable.Columns[1].DataType.Should().Be<string>();
        dataTable.Columns[2].ColumnName.Should().Be("LastName");
        dataTable.Columns[2].DataType.Should().Be<string>();
        dataTable.Columns[3].ColumnName.Should().Be("IsValidated");
        dataTable.Columns[3].DataType.Should().Be<bool>();
    }

    [Fact]
    public async Task CreateAndPopulateTable()
    {
        var userDefinition = CreateDefinition();
        userDefinition.Should().NotBeNull();
        userDefinition.Name.Should().Be("User");
        userDefinition.Fields.Count.Should().Be(5);

        var importData = CreateImportData();
        importData.Should().NotBeNull();

        var importContext = new ImportProcessContext(userDefinition, importData, "test@email.com", Activator.CreateInstance);
        importContext.Should().NotBeNull();
        importContext.Definition.Should().NotBeNull();
        importContext.ImportData.Should().NotBeNull();


        var dataTable = this.CreateTable(importContext);
        dataTable.Should().NotBeNull();

        dataTable.Columns.Count.Should().Be(5);
        dataTable.Columns[0].ColumnName.Should().Be("EmailAddress");
        dataTable.Columns[0].DataType.Should().Be<string>();

        dataTable.Columns[1].ColumnName.Should().Be("FirstName");
        dataTable.Columns[1].DataType.Should().Be<string>();

        dataTable.Columns[2].ColumnName.Should().Be("LastName");
        dataTable.Columns[2].DataType.Should().Be<string>();

        dataTable.Columns[3].ColumnName.Should().Be("IsValidated");
        dataTable.Columns[3].DataType.Should().Be<bool>();

        dataTable.Columns[4].ColumnName.Should().Be("LockoutCount");
        dataTable.Columns[4].DataType.Should().Be<int>();

        await PopulateTable(importContext, dataTable);

        dataTable.Rows.Count.Should().Be(3);

        dataTable.Rows[0][0].Should().Be("user1@email.com");
        dataTable.Rows[0][1].Should().Be("first1");
        dataTable.Rows[0][2].Should().Be("last1");
        dataTable.Rows[0][3].Should().Be(true);
        dataTable.Rows[0][4].Should().Be(DBNull.Value);

        dataTable.Rows[1][0].Should().Be("user2@email.com");
        dataTable.Rows[1][1].Should().Be("first2");
        dataTable.Rows[1][2].Should().Be("");
        dataTable.Rows[1][3].Should().Be(false);
        dataTable.Rows[1][4].Should().Be(DBNull.Value);

        dataTable.Rows[2][0].Should().Be("user3@email.com");
        dataTable.Rows[2][1].Should().Be("first3");
        dataTable.Rows[2][2].Should().Be("last3");
        dataTable.Rows[2][3].Should().Be(false);
        dataTable.Rows[2][4].Should().Be(2);

    }

    [Theory]
    [InlineData("1", typeof(int), 1)]
    [InlineData("true", typeof(bool), true)]
    [InlineData("", typeof(int?), null)]
    [InlineData("", typeof(int), 0)]
    [InlineData("test", typeof(string), "test")]
    public async Task ConvertValueTest(string value, Type type, object expected)
    {
        var fieldDefinition = new FieldDefinition();
        fieldDefinition.Name = "Test";
        fieldDefinition.DataType = type;

        var convertedValue = await ConvertValue(null, fieldDefinition, value);
        Assert.Equal(convertedValue, expected);
    }

    [Theory]
    [InlineData(FieldDefault.UserName, null, "test@user.com")]
    [InlineData(FieldDefault.Static, "testing123", "testing123")]
    [InlineData(FieldDefault.Static, 42, 42)]
    public void GetDefaultTest(FieldDefault fieldDefault, object defaultValue, object expected)
    {
        var fieldDefinition = new FieldDefinition();
        fieldDefinition.Name = "Test";
        fieldDefinition.Default = fieldDefault;
        fieldDefinition.DefaultValue = defaultValue;

        var resultValue = GetDefault(fieldDefinition, "test@user.com");
        Assert.Equal(resultValue, expected);
    }

    private static ImportData CreateImportData()
    {
        var importData = new ImportData();
        importData.FileName = "Testing.csv";
        importData.Mappings = new List<FieldMap>
        {
            new FieldMap {Name = "EmailAddress", Index = 0},
            new FieldMap {Name = "IsValidated", Index = 1},
            new FieldMap {Name = "LastName", Index = 2},
            new FieldMap {Name = "FirstName", Index = 3},
            new FieldMap {Name = "LockoutCount", Index = 4},
        };
        importData.Data = new[]
        {
            new[] {"EmailAddress", "IsValidated", "LastName", "FirstName", "LockoutCount"},
            new[] {"user1@email.com", "true", "last1", "first1", ""},
            new[] {"user2@email.com", "false", "", "first2", ""},
            new[] {"user3@email.com", "", "last3", "first3", "2"},
        };
        return importData;
    }

    private static ImportDefinition CreateDefinition()
    {
        var userDefinition = ImportDefinition.Build(b => b
            .Name("User")
            .Field(f => f
                .DisplayName("Email Address")
                .FieldName("EmailAddress")
                .DataType<string>()
                .Required()
            )
            .Field(f => f
                .DisplayName("First Name")
                .FieldName("FirstName")
                .DataType<string>()
            )
            .Field(f => f
                .DisplayName("Last Name")
                .FieldName("LastName")
                .DataType<string>()
            )
            .Field(f => f
                .DisplayName("Validated")
                .FieldName("IsValidated")
                .DataType<bool>()
            )
            .Field(f => f
                .DisplayName("Lockouts")
                .FieldName("LockoutCount")
                .DataType<int?>()
            )
        );

        return userDefinition;
    }

}

1	using System;
2	using System.Collections.Generic;
3	using System.Threading.Tasks;
4
5	using FluentAssertions;
6
7	using FluentCommand.Import;
8
9	using Xunit;
10
11	namespace FluentCommand.SqlServer.Tests;
12
13	public class ImportProcessorTests : ImportProcessor
14	{
15	public ImportProcessorTests()
16	: base(null, Activator.CreateInstance)	×
17	{
18	}	×
19
20	[Fact]
21	public void CreateTableTest()
22	{
23	var userDefinition = CreateDefinition();	×
24	userDefinition.Should().NotBeNull();	×
25	userDefinition.Name.Should().Be("User");	×
26	userDefinition.Fields.Count.Should().Be(5);	×
27
28	var importData = CreateImportData();	×
29	importData.Should().NotBeNull();	×
30
31	var importContext = new ImportProcessContext(userDefinition, importData, "test@email.com", Activator.CreateInstance);	×
32	importContext.Should().NotBeNull();	×
33	importContext.Definition.Should().NotBeNull();	×
34	importContext.ImportData.Should().NotBeNull();	×
35
36	var dataTable = this.CreateTable(importContext);	×
37	dataTable.Should().NotBeNull();	×
38	dataTable.Columns.Count.Should().Be(5);	×
39	dataTable.Columns[0].ColumnName.Should().Be("EmailAddress");	×
40	dataTable.Columns[0].DataType.Should().Be<string>();	×
41	dataTable.Columns[1].ColumnName.Should().Be("FirstName");	×
42	dataTable.Columns[1].DataType.Should().Be<string>();	×
43	dataTable.Columns[2].ColumnName.Should().Be("LastName");	×
44	dataTable.Columns[2].DataType.Should().Be<string>();	×
45	dataTable.Columns[3].ColumnName.Should().Be("IsValidated");	×
46	dataTable.Columns[3].DataType.Should().Be<bool>();	×
47	}	×
48
49	[Fact]
50	public async Task CreateAndPopulateTable()
51	{
52	var userDefinition = CreateDefinition();
53	userDefinition.Should().NotBeNull();
54	userDefinition.Name.Should().Be("User");
55	userDefinition.Fields.Count.Should().Be(5);
56
57	var importData = CreateImportData();
58	importData.Should().NotBeNull();
59
60	var importContext = new ImportProcessContext(userDefinition, importData, "test@email.com", Activator.CreateInstance);
61	importContext.Should().NotBeNull();
62	importContext.Definition.Should().NotBeNull();
63	importContext.ImportData.Should().NotBeNull();
64
65
66	var dataTable = this.CreateTable(importContext);
67	dataTable.Should().NotBeNull();
68
69	dataTable.Columns.Count.Should().Be(5);
70	dataTable.Columns[0].ColumnName.Should().Be("EmailAddress");
71	dataTable.Columns[0].DataType.Should().Be<string>();
72
73	dataTable.Columns[1].ColumnName.Should().Be("FirstName");
74	dataTable.Columns[1].DataType.Should().Be<string>();
75
76	dataTable.Columns[2].ColumnName.Should().Be("LastName");
77	dataTable.Columns[2].DataType.Should().Be<string>();
78
79	dataTable.Columns[3].ColumnName.Should().Be("IsValidated");
80	dataTable.Columns[3].DataType.Should().Be<bool>();
81
82	dataTable.Columns[4].ColumnName.Should().Be("LockoutCount");
83	dataTable.Columns[4].DataType.Should().Be<int>();
84
85	await PopulateTable(importContext, dataTable);
86
87	dataTable.Rows.Count.Should().Be(3);
88
89	dataTable.Rows[0][0].Should().Be("user1@email.com");
90	dataTable.Rows[0][1].Should().Be("first1");
91	dataTable.Rows[0][2].Should().Be("last1");
92	dataTable.Rows[0][3].Should().Be(true);
93	dataTable.Rows[0][4].Should().Be(DBNull.Value);
94
95	dataTable.Rows[1][0].Should().Be("user2@email.com");
96	dataTable.Rows[1][1].Should().Be("first2");
97	dataTable.Rows[1][2].Should().Be("");
98	dataTable.Rows[1][3].Should().Be(false);
99	dataTable.Rows[1][4].Should().Be(DBNull.Value);
100
101	dataTable.Rows[2][0].Should().Be("user3@email.com");
102	dataTable.Rows[2][1].Should().Be("first3");
103	dataTable.Rows[2][2].Should().Be("last3");
104	dataTable.Rows[2][3].Should().Be(false);
105	dataTable.Rows[2][4].Should().Be(2);
106
107	}
108
109	[Theory]
110	[InlineData("1", typeof(int), 1)]
111	[InlineData("true", typeof(bool), true)]
112	[InlineData("", typeof(int?), null)]
113	[InlineData("", typeof(int), 0)]
114	[InlineData("test", typeof(string), "test")]
115	public async Task ConvertValueTest(string value, Type type, object expected)
116	{
117	var fieldDefinition = new FieldDefinition();
118	fieldDefinition.Name = "Test";
119	fieldDefinition.DataType = type;
120
121	var convertedValue = await ConvertValue(null, fieldDefinition, value);
122	Assert.Equal(convertedValue, expected);
123	}
124
125	[Theory]
126	[InlineData(FieldDefault.UserName, null, "test@user.com")]
127	[InlineData(FieldDefault.Static, "testing123", "testing123")]
128	[InlineData(FieldDefault.Static, 42, 42)]
129	public void GetDefaultTest(FieldDefault fieldDefault, object defaultValue, object expected)
130	{
131	var fieldDefinition = new FieldDefinition();	×
132	fieldDefinition.Name = "Test";	×
133	fieldDefinition.Default = fieldDefault;	×
134	fieldDefinition.DefaultValue = defaultValue;	×
135
136	var resultValue = GetDefault(fieldDefinition, "test@user.com");	×
137	Assert.Equal(resultValue, expected);	×
138	}	×
139
140	private static ImportData CreateImportData()
141	{
142	var importData = new ImportData();	×
143	importData.FileName = "Testing.csv";	×
144	importData.Mappings = new List<FieldMap>	×
145	{	×
146	new FieldMap {Name = "EmailAddress", Index = 0},	×
147	new FieldMap {Name = "IsValidated", Index = 1},	×
148	new FieldMap {Name = "LastName", Index = 2},	×
149	new FieldMap {Name = "FirstName", Index = 3},	×
150	new FieldMap {Name = "LockoutCount", Index = 4},	×
151	};	×
152	importData.Data = new[]	×
153	{	×
154	new[] {"EmailAddress", "IsValidated", "LastName", "FirstName", "LockoutCount"},	×
155	new[] {"user1@email.com", "true", "last1", "first1", ""},	×
156	new[] {"user2@email.com", "false", "", "first2", ""},	×
157	new[] {"user3@email.com", "", "last3", "first3", "2"},	×
158	};	×
159	return importData;	×
160	}
161
162	private static ImportDefinition CreateDefinition()
163	{
164	var userDefinition = ImportDefinition.Build(b => b	×
165	.Name("User")	×
166	.Field(f => f	×
167	.DisplayName("Email Address")	×
168	.FieldName("EmailAddress")	×
169	.DataType<string>()	×
170	.Required()	×
171	)	×
172	.Field(f => f	×
173	.DisplayName("First Name")	×
174	.FieldName("FirstName")	×
175	.DataType<string>()	×
176	)	×
177	.Field(f => f	×
178	.DisplayName("Last Name")	×
179	.FieldName("LastName")	×
180	.DataType<string>()	×
181	)	×
182	.Field(f => f	×
183	.DisplayName("Validated")	×
184	.FieldName("IsValidated")	×
185	.DataType<bool>()	×
186	)	×
187	.Field(f => f	×
188	.DisplayName("Lockouts")	×
189	.FieldName("LockoutCount")	×
190	.DataType<int?>()	×
191	)	×
192	);	×
193
194	return userDefinition;	×
195	}
196
197	}

loresoft / FluentCommand / 5812535745

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous