protected MatchQueryMySqlFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(Herb), e => e?.Id }
}.ToDictionary(e => e.Key, e => (object)e.Value);
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(Herb), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
}
}
}.ToDictionary(e => e.Key, e => (object)e.Value);
QueryAsserter = new QueryAsserter <PoolableDbContext>(
CreateContext,
new MatchQueryData(),
entitySorters,
entityAsserters);
}
public NetTopologySuiteFixture()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(SpatialTypes), e => e?.Id }
};
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(SpatialTypes),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
}
}
}
};
QueryAsserter = new QueryAsserter <NetTopologySuiteContext>(
CreateContext,
new SpatialData(),
entitySorters,
entityAsserters);
}
public FunkyDataQueryFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(FunkyCustomer), e => e?.Id },
}.ToDictionary(e => e.Key, e => (object)e.Value);;
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(FunkyCustomer), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.FirstName, a.FirstName);
Assert.Equal(e.LastName, a.LastName);
Assert.Equal(e.NullableBool, a.NullableBool);
}
}
},
}.ToDictionary(e => e.Key, e => (object)e.Value);;
QueryAsserter = new QueryAsserter <FunkyDataContext>(
CreateContext,
new FunkyDataData(),
entitySorters,
entityAsserters);
}
public Task AssertFilteredQueryScalar <TResult>(
bool async,
Func <ISetSource, IQueryable <TResult> > actualQuery,
Func <ISetSource, IQueryable <TResult> > expectedQuery,
bool assertOrder = false,
[CallerMemberName] string testMethodName = null)
where TResult : struct
=> QueryAsserter.AssertQueryScalar(actualQuery, expectedQuery, assertOrder, async, testMethodName, filteredQuery : true);
public SpatialQueryFixtureBase()
{
QueryAsserter = new QueryAsserter <SpatialContext>(
CreateContext,
new SpatialData(),
entitySorters: null,
entityAsserters: null);
}
protected SpatialQueryFixtureBase()
{
QueryAsserter = new QueryAsserter <SpatialContext>(
CreateContext,
new SpatialData(GeometryFactory),
entitySorters: null,
entityAsserters: null);
}
public Task AssertFilteredQuery <TResult>(
bool async,
Func <ISetSource, IQueryable <TResult> > actualQuery,
Func <ISetSource, IQueryable <TResult> > expectedQuery,
Func <TResult, object> elementSorter = null,
Action <TResult, TResult> elementAsserter = null,
bool assertOrder = false,
int entryCount = 0,
[CallerMemberName] string testMethodName = null)
where TResult : class
=> QueryAsserter.AssertQuery(
actualQuery, expectedQuery, elementSorter, elementAsserter, assertOrder, entryCount, async, testMethodName, filteredQuery : true);
protected NorthwindQueryFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(Customer), e => e.CustomerID },
{ typeof(Order), e => e.OrderID },
{ typeof(Employee), e => e.EmployeeID },
{ typeof(Product), e => e.ProductID },
{ typeof(OrderDetail), e => e.OrderID.ToString() + " " + e.ProductID.ToString() }
};
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >();
QueryAsserter = new QueryAsserter <NorthwindContext>(
CreateContext,
new NorthwindData(),
entitySorters,
entityAsserters);
}
protected Task AssertFilteredCount <TResult>(
bool async,
Func <ISetSource, IQueryable <TResult> > actualQuery,
Func <ISetSource, IQueryable <TResult> > expectedQuery)
=> QueryAsserter.AssertCount(actualQuery, expectedQuery, async, filteredQuery: true);
protected ComplexNavigationsQueryFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(Level1), e => e.Id },
{ typeof(Level2), e => e.Id },
{ typeof(Level3), e => e.Id },
{ typeof(Level4), e => e.Id },
{ typeof(InheritanceBase1), e => e.Id },
{ typeof(InheritanceBase2), e => e.Id },
{ typeof(InheritanceDerived1), e => e.Id },
{ typeof(InheritanceDerived2), e => e.Id },
{ typeof(InheritanceLeaf1), e => e.Id },
{ typeof(InheritanceLeaf2), e => e.Id }
};
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(Level1),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Date, a.Date);
}
},
{
typeof(Level2),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Date, a.Date);
Assert.Equal(e.Level1_Optional_Id, a.Level1_Optional_Id);
Assert.Equal(e.Level1_Required_Id, a.Level1_Required_Id);
}
},
{
typeof(Level3),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Level2_Optional_Id, a.Level2_Optional_Id);
Assert.Equal(e.Level2_Required_Id, a.Level2_Required_Id);
}
},
{
typeof(Level4),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Level3_Optional_Id, a.Level3_Optional_Id);
Assert.Equal(e.Level3_Required_Id, a.Level3_Required_Id);
}
},
{
typeof(InheritanceBase1),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
},
{
typeof(InheritanceBase2),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
},
{
typeof(InheritanceDerived1),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
},
{
typeof(InheritanceDerived2),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
},
{
typeof(InheritanceLeaf1),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
},
{
typeof(InheritanceLeaf2),
(e, a) =>
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
}
};
QueryAsserter = new QueryAsserter <ComplexNavigationsContext>(
CreateContext,
new ComplexNavigationsDefaultData(),
entitySorters,
entityAsserters);
}
protected GearsOfWarQueryFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(City), e => e?.Name },
{ typeof(CogTag), e => e?.Id },
{ typeof(Faction), e => e?.Id },
{ typeof(LocustHorde), e => e?.Id },
{ typeof(Gear), e => e?.SquadId + " " + e?.Nickname },
{ typeof(Officer), e => e?.SquadId + " " + e?.Nickname },
{ typeof(LocustLeader), e => e?.Name },
{ typeof(LocustCommander), e => e?.Name },
{ typeof(Mission), e => e?.Id },
{ typeof(Squad), e => e?.Id },
{ typeof(SquadMission), e => e?.SquadId + " " + e?.MissionId },
{ typeof(Weapon), e => e?.Id },
{ typeof(LocustHighCommand), e => e?.Id }
};
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(City),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Location, a.Location);
Assert.Equal(e[City.NationPropertyName], a[City.NationPropertyName]);
}
}
},
{
typeof(CogTag),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Note, a.Note);
Assert.Equal(e.GearNickName, a.GearNickName);
Assert.Equal(e.GearSquadId, a.GearSquadId);
}
}
},
{
typeof(Faction),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.CapitalName, a.CapitalName);
}
}
},
{
typeof(Gear),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Nickname, a.Nickname);
Assert.Equal(e.SquadId, a.SquadId);
Assert.Equal(e.CityOrBirthName, a.CityOrBirthName);
Assert.Equal(e.FullName, a.FullName);
Assert.Equal(e.HasSoulPatch, a.HasSoulPatch);
Assert.Equal(e.LeaderNickname, a.LeaderNickname);
Assert.Equal(e.LeaderSquadId, a.LeaderSquadId);
Assert.Equal(e.Rank, a.Rank);
}
}
},
{
typeof(LocustCommander),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.ThreatLevel, a.ThreatLevel);
Assert.Equal(e.DefeatedByNickname, a.DefeatedByNickname);
Assert.Equal(e.DefeatedBySquadId, a.DefeatedBySquadId);
}
}
},
{
typeof(LocustHorde),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.CapitalName, a.CapitalName);
Assert.Equal(e.CommanderName, a.CommanderName);
Assert.Equal(e.Eradicated, a.Eradicated);
}
}
},
{
typeof(LocustLeader),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.ThreatLevel, a.ThreatLevel);
}
}
},
{
typeof(Mission),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.CodeName, a.CodeName);
Assert.Equal(e.Rating, a.Rating);
Assert.Equal(e.Timeline, a.Timeline);
}
}
},
{
typeof(Officer),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Nickname, a.Nickname);
Assert.Equal(e.SquadId, a.SquadId);
Assert.Equal(e.CityOrBirthName, a.CityOrBirthName);
Assert.Equal(e.FullName, a.FullName);
Assert.Equal(e.HasSoulPatch, a.HasSoulPatch);
Assert.Equal(e.LeaderNickname, a.LeaderNickname);
Assert.Equal(e.LeaderSquadId, a.LeaderSquadId);
Assert.Equal(e.Rank, a.Rank);
}
}
},
{
typeof(Squad),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
}
}
},
{
typeof(SquadMission),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.SquadId, a.SquadId);
Assert.Equal(e.MissionId, a.MissionId);
}
}
},
{
typeof(Weapon),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.IsAutomatic, a.IsAutomatic);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.OwnerFullName, a.OwnerFullName);
Assert.Equal(e.SynergyWithId, a.SynergyWithId);
}
}
}
};
QueryAsserter = new QueryAsserter <GearsOfWarContext>(
CreateContext,
new GearsOfWarData(),
entitySorters,
entityAsserters);
}
public OwnedQueryFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(OwnedPerson), e => e?.Id },
{ typeof(Branch), e => e?.Id },
{ typeof(LeafA), e => e?.Id },
{ typeof(LeafB), e => e?.Id },
{ typeof(Planet), e => e?.Id },
{ typeof(Star), e => e?.Id },
{ typeof(Moon), e => e?.Id },
{ typeof(Fink), e => e?.Id },
{ typeof(Barton), e => e?.Id },
// owned entities - still need comparers in case they are projected directly
{ typeof(Order), e => e?.Id },
{ typeof(Element), e => e?.Id },
{ typeof(Throned), e => e?.Property },
};
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(OwnedPerson), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
AssertAddress(e.PersonAddress, a.PersonAddress);
AssertOrders(e.Orders, a.Orders);
}
}
},
{
typeof(Branch), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
AssertAddress(e.PersonAddress, a.PersonAddress);
AssertAddress(e.BranchAddress, a.BranchAddress);
AssertOrders(e.Orders, a.Orders);
}
}
},
{
typeof(LeafA), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
AssertAddress(e.PersonAddress, a.PersonAddress);
AssertAddress(e.BranchAddress, a.BranchAddress);
AssertAddress(e.LeafAAddress, a.LeafAAddress);
AssertOrders(e.Orders, a.Orders);
}
}
},
{
typeof(LeafB), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
AssertAddress(e.PersonAddress, a.PersonAddress);
AssertAddress(e.LeafBAddress, a.LeafBAddress);
AssertOrders(e.Orders, a.Orders);
}
}
},
{
typeof(Planet), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.StarId, a.StarId);
}
}
},
{
typeof(Star), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Composition.Count, a.Composition.Count);
for (var i = 0; i < e.Composition.Count; i++)
{
Assert.Equal(e.Composition[i].Id, a.Composition[i].Id);
Assert.Equal(e.Composition[i].Name, a.Composition[i].Name);
Assert.Equal(e.Composition[i].StarId, a.Composition[i].StarId);
}
}
}
},
{
typeof(Moon), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.PlanetId, a.PlanetId);
Assert.Equal(e.Diameter, a.Diameter);
}
}
},
{
typeof(Fink), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
}
}
},
{
typeof(Barton), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Simple, a.Simple);
Assert.Equal(e.Throned.Property, a.Throned.Property);
}
}
},
// owned entities - still need comparers in case they are projected directly
{
typeof(Order), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
}
}
},
{
typeof(Element), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.StarId, a.StarId);
}
}
},
{
typeof(Throned), (e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Property, a.Property);
}
}
},
};
QueryAsserter = new QueryAsserter <PoolableDbContext>(
CreateContext,
new OwnedQueryData(),
entitySorters,
entityAsserters);
}
protected ParameterizedQueryFixtureBase()
{
var entitySorters = new Dictionary <Type, Func <dynamic, object> >
{
{ typeof(Person), e => e?.FirstName + e?.LastName },
{ typeof(Location), e => e?.Location },
{ typeof(RainbowType), e => e?.Name },
{ typeof(RainbowSighting), e => e?.SeenTime }
};
var entityAsserters = new Dictionary <Type, Action <dynamic, dynamic> >
{
{
typeof(Person),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.FirstName, a.FirstName);
Assert.Equal(e.LastName, a.LastName);
}
}
},
{
typeof(RainbowType),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.NumberOfRainbows, a.NumberOfRainbows);
}
}
},
{
typeof(Location),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.Name, a.Name);
Assert.Equal(e.Longitude, a.Longitude);
Assert.Equal(e.Latitude, a.Latitude);
}
}
},
{
typeof(RainbowSighting),
(e, a) =>
{
Assert.Equal(e == null, a == null);
if (a != null)
{
Assert.Equal(e.Id, a.Id);
Assert.Equal(e.RainbowTypeId, a.RainbowTypeId);
Assert.Equal(e.PersonId, a.PersonId);
Assert.Equal(e.LocationId, a.LocationId);
Assert.Equal(e.SeenTime, a.SeenTime);
Assert.Equal(e.Duration, a.Duration);
}
}
}
};
QueryAsserter = new QueryAsserter <RainbowsContext>(
CreateContext,
new RainbowsData(),
entitySorters,
entityAsserters);
}
