Skip to content

Commit 105b2c6

Browse files
tibitothtibitoth
committed
ToPagedListAsync tests
1 parent 4f421c9 commit 105b2c6

12 files changed

+300
-222
lines changed

‎test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.IsSortable.cs‎

Lines changed: 13 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -6,18 +6,21 @@
66

77
namespace AutSoft.Linq.Tests.Queryable.OrderByExtensions;
88

9-
public partial class IsSortable : OrderByExtensionsTests
9+
public partial class OrderByExtensionsTests
1010
{
11-
public static TheoryData<PropertyInfo?, bool> SortablePropertyTheoryData => new()
11+
public class IsSortable : OrderByExtensionsTests
1212
{
13-
{ typeof(PersonDto).GetProperty(nameof(PersonDto.Age)), true },
14-
{ typeof(PersonDto).GetProperty(nameof(PersonDto.Address)), false },
15-
};
13+
public static TheoryData<PropertyInfo?, bool> SortablePropertyTheoryData => new()
14+
{
15+
{ typeof(PersonDto).GetProperty(nameof(PersonDto.Age)), true },
16+
{ typeof(PersonDto).GetProperty(nameof(PersonDto.Address)), false },
17+
};
1618

17-
[Theory]
18-
[MemberData(nameof(SortablePropertyTheoryData))]
19-
public void Should_ReturnCorrentIncication(PropertyInfo? propertyInfo, bool expectedResult)
20-
{
21-
propertyInfo!.IsSortable().Should().Be(expectedResult);
19+
[Theory]
20+
[MemberData(nameof(SortablePropertyTheoryData))]
21+
public void Should_ReturnCorrentIncication(PropertyInfo? propertyInfo, bool expectedResult)
22+
{
23+
propertyInfo!.IsSortable().Should().Be(expectedResult);
24+
}
2225
}
2326
}

‎test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.OrderByFluent.cs‎

Lines changed: 18 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -5,23 +5,26 @@
55

66
namespace AutSoft.Linq.Tests.Queryable.OrderByExtensions;
77

8-
public partial class OrderByFluent : OrderByExtensionsTests
8+
public partial class OrderByExtensionsTests
99
{
10-
[Theory]
11-
[InlineData(OrderDirection.Ascending)]
12-
[InlineData(OrderDirection.Descending)]
13-
public void Should_ReturnOrdered(OrderDirection orderDirection)
10+
public class OrderByFluent : OrderByExtensionsTests
1411
{
15-
// Act
16-
var ordered = Subject.OrderBy(x => x.Name, orderDirection).ToList();
17-
18-
// Assert
19-
ordered.Should().HaveCount(Subject.Count());
20-
_ = orderDirection switch
12+
[Theory]
13+
[InlineData(OrderDirection.Ascending)]
14+
[InlineData(OrderDirection.Descending)]
15+
public void Should_ReturnOrdered(OrderDirection orderDirection)
2116
{
22-
OrderDirection.Ascending => ordered.Should().BeInAscendingOrder(p => p.Name),
23-
OrderDirection.Descending => ordered.Should().BeInDescendingOrder(p => p.Name),
24-
_ => throw new NotSupportedException(),
25-
};
17+
// Act
18+
var ordered = Subject.OrderBy(x => x.Name, orderDirection).ToList();
19+
20+
// Assert
21+
ordered.Should().HaveCount(Subject.Count());
22+
_ = orderDirection switch
23+
{
24+
OrderDirection.Ascending => ordered.Should().BeInAscendingOrder(p => p.Name),
25+
OrderDirection.Descending => ordered.Should().BeInDescendingOrder(p => p.Name),
26+
_ => throw new NotSupportedException(),
27+
};
28+
}
2629
}
2730
}

‎test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.OrderByFromEFModel.cs‎

Lines changed: 33 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -7,40 +7,43 @@
77

88
namespace AutSoft.Linq.Tests.Queryable.OrderByExtensions;
99

10-
public partial class OrderByFromEFModel : OrderByExtensionsTests
10+
public partial class OrderByExtensionsTests
1111
{
12-
public static List<(string orderColumn, Expression<Func<Person, object?>> expectedOrderExpression)> DefaultOrderExpression() => new()
12+
public class OrderByFromEFModel : OrderByExtensionsTests
1313
{
14-
(nameof(Person.Id), p => p.Id),
15-
(nameof(Person.Name), p => p.Name),
16-
(nameof(Person.Address), p => p.Address),
17-
(nameof(Person.DateOfBirth), p => p.DateOfBirth),
18-
};
19-
20-
[Theory]
21-
[CombinatorialData]
22-
public void Should_ReturnOrdered(
23-
[CombinatorialMemberData(nameof(DefaultOrderExpression))] (string orderColumn, Expression<Func<Person, object?>> expectedOrderExpression) ordering,
24-
OrderDirection orderDirection)
25-
{
26-
// Act
27-
var ordered = Subject
28-
.OrderBy(new PageRequest { OrderBy = ordering.orderColumn, OrderDirection = orderDirection }, p => p.Id)
29-
.ToList();
30-
31-
// Assert
32-
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
33-
if (orderDirection is OrderDirection.Ascending)
34-
{
35-
ordered.Should().BeInAscendingOrder(ordering.expectedOrderExpression);
36-
}
37-
else if (orderDirection is OrderDirection.Descending)
14+
public static List<(string orderColumn, Expression<Func<Person, object?>> expectedOrderExpression)> DefaultOrderExpression() => new()
3815
{
39-
ordered.Should().BeInDescendingOrder(ordering.expectedOrderExpression);
40-
}
41-
else
16+
(nameof(Person.Id), p => p.Id),
17+
(nameof(Person.Name), p => p.Name),
18+
(nameof(Person.Address), p => p.Address),
19+
(nameof(Person.DateOfBirth), p => p.DateOfBirth),
20+
};
21+
22+
[Theory]
23+
[CombinatorialData]
24+
public void Should_ReturnOrdered(
25+
[CombinatorialMemberData(nameof(DefaultOrderExpression))] (string orderColumn, Expression<Func<Person, object?>> expectedOrderExpression) ordering,
26+
OrderDirection orderDirection)
4227
{
43-
throw new NotSupportedException("Not valid test case input");
28+
// Act
29+
var ordered = Subject
30+
.OrderBy(new PageRequest { OrderBy = ordering.orderColumn, OrderDirection = orderDirection }, p => p.Id)
31+
.ToList();
32+
33+
// Assert
34+
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
35+
if (orderDirection is OrderDirection.Ascending)
36+
{
37+
ordered.Should().BeInAscendingOrder(ordering.expectedOrderExpression);
38+
}
39+
else if (orderDirection is OrderDirection.Descending)
40+
{
41+
ordered.Should().BeInDescendingOrder(ordering.expectedOrderExpression);
42+
}
43+
else
44+
{
45+
throw new NotSupportedException("Not valid test case input");
46+
}
4447
}
4548
}
4649
}

‎test/AutSoft.Linq.Tests/Queryable/OrderByExtensions/OrderByExtensionsTests.OrderByFromMappings.cs‎

Lines changed: 114 additions & 105 deletions
Original file line numberDiff line numberDiff line change
@@ -10,127 +10,136 @@
1010

1111
namespace AutSoft.Linq.Tests.Queryable.OrderByExtensions;
1212

13-
public partial class OrderByFromMappings : OrderByExtensionsTests
13+
public partial class OrderByExtensionsTests
1414
{
15-
public static List<(string orderColumn, Expression<Func<PersonDto, object?>> expectedOrderExpression)> OrderExpression() => new()
15+
public class OrderByFromMappings : OrderByExtensionsTests
1616
{
17-
(nameof(PersonDto.Id), p => p.Id),
18-
(nameof(PersonDto.Name), p => p.Name),
19-
(nameof(PersonDto.Age), p => p.Age),
20-
};
21-
22-
[Theory]
23-
[CombinatorialData]
24-
public void Should_ReturnOrdered(
25-
[CombinatorialMemberData(nameof(OrderExpression))] (string orderColumn, Expression<Func<PersonDto, object?>> expectedOrderExpression) ordering,
26-
OrderDirection orderDirection)
27-
{
28-
// Act
29-
var ordered = Subject
30-
.OrderBy<Person, PersonDto>(new PageRequest { OrderBy = ordering.orderColumn, OrderDirection = orderDirection }, p => p.Id, Mapper.ConfigurationProvider)
31-
.ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
32-
.ToList();
33-
34-
// Assert
35-
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
36-
if (orderDirection is OrderDirection.Ascending)
37-
{
38-
ordered.Should().BeInAscendingOrder(ordering.expectedOrderExpression);
39-
}
40-
else if (orderDirection is OrderDirection.Descending)
17+
public static List<(string orderColumn, Expression<Func<PersonDto, object?>> expectedOrderExpression)> OrderExpression() => new()
4118
{
42-
ordered.Should().BeInDescendingOrder(ordering.expectedOrderExpression);
43-
}
44-
else
19+
(nameof(PersonDto.Id), p => p.Id),
20+
(nameof(PersonDto.Name), p => p.Name),
21+
(nameof(PersonDto.Age), p => p.Age),
22+
};
23+
24+
[Theory]
25+
[CombinatorialData]
26+
public void Should_ReturnOrdered(
27+
[CombinatorialMemberData(nameof(OrderExpression))] (string orderColumn, Expression<Func<PersonDto, object?>> expectedOrderExpression) ordering,
28+
OrderDirection orderDirection)
4529
{
46-
throw new NotSupportedException("Not valid test case input");
30+
// Act
31+
var ordered = Subject
32+
.OrderBy<Person, PersonDto>(
33+
new PageRequest { OrderBy = ordering.orderColumn, OrderDirection = orderDirection },
34+
p => p.Id,
35+
Mapper.ConfigurationProvider)
36+
.ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
37+
.ToList();
38+
39+
// Assert
40+
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
41+
if (orderDirection is OrderDirection.Ascending)
42+
{
43+
ordered.Should().BeInAscendingOrder(ordering.expectedOrderExpression);
44+
}
45+
else if (orderDirection is OrderDirection.Descending)
46+
{
47+
ordered.Should().BeInDescendingOrder(ordering.expectedOrderExpression);
48+
}
49+
else
50+
{
51+
throw new NotSupportedException("Not valid test case input");
52+
}
4753
}
48-
}
4954

50-
public static List<(Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression)> DefaultOrderExpression() => new()
51-
{
52-
(p => p.Id, p => p.Id),
53-
(p => p.Name, p => p.Name),
54-
(p => p.Address, p => p.Address),
55-
};
56-
57-
[Theory]
58-
[CombinatorialData]
59-
public void Should_ReturnDefaultOrdered_WithoutOrderingInfo(
60-
[CombinatorialMemberData(nameof(DefaultOrderExpression))]
61-
(Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression) expressions,
62-
OrderDirection orderDirection)
63-
{
64-
// Act
65-
var ordered = Subject
66-
.OrderBy<Person, PersonDto>(new PageRequest() { OrderDirection = orderDirection }, expressions.defaultOrderExpression, Mapper.ConfigurationProvider)
67-
.ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
68-
.ToList();
69-
70-
// Assert
71-
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
72-
if (orderDirection is OrderDirection.Ascending)
73-
{
74-
ordered.Should().BeInAscendingOrder(expressions.expectedOrderExpression);
75-
}
76-
else if (orderDirection is OrderDirection.Descending)
55+
public static List<(Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression)> DefaultOrderExpression() => new()
7756
{
78-
ordered.Should().BeInDescendingOrder(expressions.expectedOrderExpression);
79-
}
80-
else
57+
(p => p.Id, p => p.Id),
58+
(p => p.Name, p => p.Name),
59+
(p => p.Address, p => p.Address),
60+
};
61+
62+
[Theory]
63+
[CombinatorialData]
64+
public void Should_ReturnDefaultOrdered_WithoutOrderingInfo(
65+
[CombinatorialMemberData(nameof(DefaultOrderExpression))]
66+
(Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression) expressions,
67+
OrderDirection orderDirection)
8168
{
82-
throw new NotSupportedException("Not valid test case input");
69+
// Act
70+
var ordered = Subject
71+
.OrderBy<Person, PersonDto>(
72+
new PageRequest() { OrderDirection = orderDirection },
73+
expressions.defaultOrderExpression,
74+
Mapper.ConfigurationProvider)
75+
.ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
76+
.ToList();
77+
78+
// Assert
79+
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
80+
if (orderDirection is OrderDirection.Ascending)
81+
{
82+
ordered.Should().BeInAscendingOrder(expressions.expectedOrderExpression);
83+
}
84+
else if (orderDirection is OrderDirection.Descending)
85+
{
86+
ordered.Should().BeInDescendingOrder(expressions.expectedOrderExpression);
87+
}
88+
else
89+
{
90+
throw new NotSupportedException("Not valid test case input");
91+
}
8392
}
84-
}
8593

86-
[Theory]
87-
[CombinatorialData]
88-
public void Should_ReturnDefaultOrdered_WithDefaultOrderDirection(
89-
[CombinatorialMemberData(nameof(DefaultOrderExpression))]
94+
[Theory]
95+
[CombinatorialData]
96+
public void Should_ReturnDefaultOrdered_WithDefaultOrderDirection(
97+
[CombinatorialMemberData(nameof(DefaultOrderExpression))]
9098
(Expression<Func<Person, object?>> defaultOrderExpression, Expression<Func<PersonDto, object?>> expectedOrderExpression) expressions,
91-
OrderDirection defaultOrderDirection)
92-
{
93-
// Act
94-
var ordered = Subject
95-
.OrderBy<Person, PersonDto>(new PageRequest(), expressions.defaultOrderExpression, defaultOrderDirection, Mapper.ConfigurationProvider)
96-
.ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
97-
.ToList();
98-
99-
// Assert
100-
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
101-
if (defaultOrderDirection is OrderDirection.Ascending)
102-
{
103-
ordered.Should().BeInAscendingOrder(expressions.expectedOrderExpression);
104-
}
105-
else if (defaultOrderDirection is OrderDirection.Descending)
99+
OrderDirection defaultOrderDirection)
106100
{
107-
ordered.Should().BeInDescendingOrder(expressions.expectedOrderExpression);
101+
// Act
102+
var ordered = Subject
103+
.OrderBy<Person, PersonDto>(new PageRequest(), expressions.defaultOrderExpression, defaultOrderDirection, Mapper.ConfigurationProvider)
104+
.ProjectTo<PersonDto>(Mapper.ConfigurationProvider)
105+
.ToList();
106+
107+
// Assert
108+
ordered.Should().HaveCount(Subject.Count()).And.HaveCountGreaterThan(0);
109+
if (defaultOrderDirection is OrderDirection.Ascending)
110+
{
111+
ordered.Should().BeInAscendingOrder(expressions.expectedOrderExpression);
112+
}
113+
else if (defaultOrderDirection is OrderDirection.Descending)
114+
{
115+
ordered.Should().BeInDescendingOrder(expressions.expectedOrderExpression);
116+
}
117+
else
118+
{
119+
throw new NotSupportedException("Not valid test case input");
120+
}
108121
}
109-
else
110-
{
111-
throw new NotSupportedException("Not valid test case input");
112-
}
113-
}
114122

115-
[Fact]
116-
public void Should_ThrowOnNotSortableColumn()
117-
{
118-
// Act
119-
var func = () => Subject
120-
.OrderBy<Person, PersonDto>(new PageRequest { OrderBy = nameof(PersonDto.Address) }, p => p.Id, Mapper.ConfigurationProvider);
123+
[Fact]
124+
public void Should_ThrowOnNotSortableColumn()
125+
{
126+
// Act
127+
var func = () => Subject
128+
.OrderBy<Person, PersonDto>(new PageRequest { OrderBy = nameof(PersonDto.Address) }, p => p.Id, Mapper.ConfigurationProvider);
121129

122-
// Assert
123-
func.Should().Throw<ValidationException>();
124-
}
130+
// Assert
131+
func.Should().Throw<ValidationException>();
132+
}
125133

126-
[Fact]
127-
public void Should_ThrowOnNotExistedColumn()
128-
{
129-
// Act
130-
var func = () => Subject
131-
.OrderBy<Person, PersonDto>(new PageRequest { OrderBy = "TEST" }, p => p.Id, Mapper.ConfigurationProvider);
134+
[Fact]
135+
public void Should_ThrowOnNotExistedColumn()
136+
{
137+
// Act
138+
var func = () => Subject
139+
.OrderBy<Person, PersonDto>(new PageRequest { OrderBy = "TEST" }, p => p.Id, Mapper.ConfigurationProvider);
132140

133-
// Assert
134-
func.Should().Throw<ValidationException>();
141+
// Assert
142+
func.Should().Throw<ValidationException>();
143+
}
135144
}
136145
}

0 commit comments

Comments
 (0)