public void Initialise(string[] args)
{
var folder = args.First();
FileName = Path.Combine(folder, RootXml + ".resource");
if (!File.Exists(FileName))
{
_dataFile = XDocument.Parse("<WebMinder></WebMinder>");
_dataFile.Save(FileName);
}
_dataFile = XDocument.Load(FileName);
//Run query
var posts = from lv1 in _dataFile.Descendants(RootXml)
select lv1;
if (Items == null)
{
Items = new EnumerableQuery <T>(new List <T>());
}
var items = new List <T>();
posts.Where(x => x.HasElements)
.ToList()
.ForEach(x => items.Add(Deserialize(x.Element(typeof(T).Name).Value)));
Items = items.AsQueryable();
}
public override IOrderedQueryable <T> GetItemLinqQueryable <T>(bool allowSynchronousQueryExecution = false, string continuationToken = null, QueryRequestOptions requestOptions = null)
{
var r = new EnumerableQuery <T>(Enumerable.Empty <T>());
var returnValue = r.OrderBy(_ => _);
return(returnValue);
}
public void GetByOrganizationWithPublic_Access_ReturnOk()
{
// Arrange
const int orgKey = 1;
const int contractKey = 1;
ExpectGetOrganizationalReadAccessReturns(orgKey, OrganizationDataReadAccessLevel.Public);
IQueryable <EconomyStream> list = new EnumerableQuery <EconomyStream>(new List <EconomyStream> {
new EconomyStream {
AccessModifier = AccessModifier.Public, ExternPaymentFor = new ItContract {
Id = contractKey, OrganizationId = orgKey
}
}
});
_economyStreamRepository.Setup(x => x.AsQueryable()).Returns(list);
// Act
var result = _sut.GetByOrganization(orgKey);
// Assert
Assert.IsType <OkNegotiatedContentResult <IQueryable <EconomyStream> > >(result);
var okNegotiatedContentResult = result as OkNegotiatedContentResult <IQueryable <EconomyStream> >;
if (okNegotiatedContentResult == null)
{
return;
}
var data = okNegotiatedContentResult.Content;
Assert.Equal(list, data);
}
public void GetByOrganization_Access_ReturnOk()
{
// Arrange
const int orgKey = 1;
ExpectGetOrganizationalReadAccessReturns(orgKey, OrganizationDataReadAccessLevel.All);
IQueryable <EconomyStream> list = new EnumerableQuery <EconomyStream>(new List <EconomyStream>());
_economyStreamRepository.Setup(x => x.AsQueryable()).Returns(list);
// Act
var result = _sut.GetByOrganization(orgKey);
// Assert
Assert.IsType <OkNegotiatedContentResult <IQueryable <EconomyStream> > >(result);
var okNegotiatedContentResult = result as OkNegotiatedContentResult <IQueryable <EconomyStream> >;
if (okNegotiatedContentResult == null)
{
return;
}
var data = okNegotiatedContentResult.Content;
Assert.Equal(list, data);
}
protected override IQueryable <TElement> CreateQueryOverride <TElement>(Expression expression)
{
var enumerableQuery = new EnumerableQuery <TElement>(expression);
var resultQueryable = ((IQueryProvider)enumerableQuery).CreateQuery <TElement>(expression);
return(new RemoteQueryable <TElement>(this, resultQueryable.Expression));
}
public void Should_return_zero_search_results()
{
PatientDto expectedDto = new PatientDto()
{
Id = Guid.NewGuid(),
Name = "Jeff Carley",
Status = "Active",
Street = "123 Main St",
City = "Madison",
State = "WI",
Zip = "53571"
};
var query = new EnumerableQuery <PatientDto>(new List <PatientDto>()
{
expectedDto
});
IReportingRepository <PatientDto> repository = MockRepository.GenerateMock <IReportingRepository <PatientDto> >();
repository.Stub(repo => repo.GetAll()).Return(query);
PatientSearchViewModel viewModel = new PatientSearchViewModel(repository);
// searchs are exact only
viewModel.SearchText = "Jeff";
viewModel.Search.Execute(null);
viewModel.PatientResults.ShouldBeEmpty();
}
public void FromExpressionReturnsSameExpression()
{
ConstantExpression exp = Expression.Constant(new[] { 1, 2, 3 });
IQueryable <int> query = new EnumerableQuery <int>(exp);
Assert.Same(exp, query.Expression);
}
public void GetOrdersByCustomerId()
{
// Arrange
var orders = new EnumerableQuery <Orders>(
new List <Orders>
{
new Orders
{
OrderID = 10248,
CustomerID = "VINET",
Customers = new Customers {
CustomerID = "VINET"
}
},
new Orders
{
OrderID = 10249,
CustomerID = null,
Customers = null
}
});
// Act
var result = orders.GetOrdersByCustomerId("VINET");
// Assert
result.ShouldBeEquivalentTo(new List <Orders> {
new Orders {
OrderID = 10248, CustomerID = "VINET", Customers = new Customers {
CustomerID = "VINET"
}
}
});
}
public async Task EnsureCreatedCreatesCollectionIfMissing()
{
// Arrange
IOrderedQueryable <DocumentCollection> queryable = new EnumerableQuery <DocumentCollection>(new List <DocumentCollection>());
_mockDocumentClient.Setup(x =>
x.CreateDocumentCollectionQuery(It.IsAny <string>(), It.IsAny <FeedOptions>())).Returns(queryable);
var collection = new DocumentCollection {
Id = "collection"
};
var collectionResponse = collection.ToResourceResponse(HttpStatusCode.OK);
var databaseUri = UriFactory.CreateDatabaseUri("databaseName");
_mockDocumentClient.Setup(x => x.CreateDocumentCollectionAsync(It.Is <Uri>(uri => uri == databaseUri),
It.Is <DocumentCollection>(coll => coll.Id == collection.Id),
It.IsAny <RequestOptions>())).ReturnsAsync(collectionResponse);
var creator = new CosmosCollectionCreator(new CosmonautClient(_mockDocumentClient.Object));
// Act
var result = await creator.EnsureCreatedAsync <Dummy>("databaseName", collection.Id, 500, new JsonSerializerSettings());
// Assert
result.Should().BeTrue();
}
public IEnumerable <T> CreateSplittedEnumerable <TInner>(MethodCallExpression call, Expression innerExpression)
{
IEnumerable <TInner> enumerable = Query.Provider.CreateQuery <TInner>(innerExpression);
// We need to ask for the GetEnumerator to be able to check the query
// This call will throw if the LINQ-to-SQL can't produce the query
IEnumerator <TInner> enumerator = enumerable.GetEnumerator();
// Success!
// We transform back the enumerator to an enumerable
IEnumerable <TInner> enumerable2 = new FakeEnumerable <TInner>(enumerator, enumerable);
// "Quick-n-dirty". We use a fake Queryable. The "right" way would probably be
// transform all the outer query from IQueryable.Method<T> to IEnumerable.Method<T>
// Too much long :)
// Note that this Queryable is executed in "local" (the AsQueryable<T> method is nearly
// useless... The second time in my life I was able to use it for something)
IQueryable <TInner> queryable = Queryable.AsQueryable(enumerable2);
// We rebuild a new expression by changing the "old" inner parameter
// of the MethodCallExpression with the queryable we just
// built
Expression expression2 = new SimpleExpressionReplacer {
Call = call, Queryable = queryable
}.Visit(Query.Expression);
// We "execute" locally the whole query through a second
// "outer" instance of the EnumerableQuery (this class is
// the class that "implements" the "fake-magic" of AsQueryable)
EnumerableQuery <T> query2 = new EnumerableQuery <T>(expression2);
// And we return an enumerator to it
return(query2.AsEnumerable());
}
public void NullExpressionAllowed()
{
IQueryable <int> query = new EnumerableQuery <int>((Expression)null);
Assert.Null(query.Expression);
Assert.Throws <ArgumentNullException>(() => query.GetEnumerator());
}
public void FilteryByPublished_articles_returns_published_articles_when_filter_by_published_false()
{
var query = new EnumerableQuery <Article>(_articles).FilteryByPublished(false);
query.Count().Should().Be(1);
query.Each(x => x.IsPublished.Should().Be.True());
}
public void GroupBy_AfterFirst(string territoryId)
{
// Arrange
var territories = new EnumerableQuery <Territories>(
new List <Territories>
{
new Territories
{
TerritoryID = "02903",
TerritoryDescription = "Providence",
RegionID = 1,
Region = new Region {
RegionID = 1, RegionDescription = "Eastern"
}
}
});
// Act
var result = territories.GetRegionByTerritoryIdWithFirstAfter(territoryId);
// Assert
result.ShouldBeEquivalentTo(new Region {
RegionID = 1, RegionDescription = "Eastern"
});
}
public JobApplicationApiControllerTest()
{
var logger = Substitute.For <ILogger <JobApplicationsController> >();
_jobApplicationService = Substitute.For <IJobApplicationService>();
_jobApplicationsController = new JobApplicationsController(_jobApplicationService, logger);
_expectedjobApplications = new EnumerableQuery <JobApplication>(new[]
{
new JobApplication
{
CompanyName = "Company 1",
ApplicationDate =
new DateTime(2017, 11, 13),
Status = Status.Interview
},
new JobApplication
{
CompanyName = "Company 2",
ApplicationDate =
new DateTime(2017, 11, 14),
Status = Status.Applied
},
new JobApplication
{
CompanyName = "Company 3",
ApplicationDate =
new DateTime(2017, 11, 14),
Status = Status.Offer
}
});
}
public void GivenEnumerableQueryWhenTargetIsNotEnumerableQueryThenValuesAreEquivalentShouldBeFalse()
{
var enumerableQuery = new EnumerableQuery <string>(Expression.Constant("this"));
var notEnumerableQuery = new List <int>();
Assert.False(eq.ValuesAreEquivalent(enumerableQuery, notEnumerableQuery));
}
public void ExpressionToQueryByConstructor()
{
Expression exp = Expression.Constant(Enumerable.Range(0, 2).AsQueryable());
IQueryable <int> q = new EnumerableQuery <int>(exp);
Assert.Equal(Enumerable.Range(0, 2), q);
}
public void InappropriateExpressionType()
{
IQueryable <int> query = new EnumerableQuery <int>(Expression.Constant(Math.PI));
Assert.NotNull(query.Expression);
AssertExtensions.Throws <ArgumentException>(null, () => query.GetEnumerator());
}
public Form1()
{
InitializeComponent();
IQueryable <ProductCollection <BikeProduct> > titi = new EnumerableQuery <ProductCollection <BikeProduct> >(new List <ProductCollection <BikeProduct> >());
titi.ListedProducts();
var toto = 1;
}
public void GivenEnumerableQueryWhenQueryRootIsNullThenShouldReturnNullConstant()
{
EnumerableQuery <int> query = new EnumerableQuery <int>(Expression.Constant(new int[2]));
var serialized = TestSerializer.GetSerializedFragment <Constant, ConstantExpression>(Expression.Constant(query));
var deserialized = serializer.Deserialize(serialized, new SerializationState());
Assert.Null(deserialized.Value);
}
public void CanIterateEnumerableQuery()
{
var query = new EnumerableQuery <int>(new[] { 1, 2, 3, 4, 5 })
.Where(i => i % 2 == 0)
.AsInjectableQueryable();
Assert.True(new[] { 2, 4 }.SequenceEqual(query.ToList()));
}
/// <summary>
/// Find result with condition
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual IQueryable <T> Find(Expression <Func <T, bool> > predicate)
{
IEnumerable <T> enumerable = dataContext.Set <T>().Where(predicate);
EnumerableQuery <T> queryable = new EnumerableQuery <T>(enumerable);
return(queryable);
}
public void GivenEnumerableQueryWhenQueryRootIsNullThenShouldReturnNullConstant()
{
EnumerableQuery <int> query = new EnumerableQuery <int>(Expression.Constant(new int[2]));
var serialized = serializer.Serialize(Expression.Constant(query), TestSerializer.GetDefaultState());
var deserialized = serializer.Deserialize(serialized, TestSerializer.State);
Assert.Null(deserialized.Value);
}
public void NullEnumerableConstantNullExpression()
{
IQueryable <int> query = new EnumerableQuery <int>((IEnumerable <int>)null);
var exp = (ConstantExpression)query.Expression;
Assert.Same(query, exp.Value);
Assert.Throws <InvalidOperationException>(() => query.GetEnumerator());
}
public IQueryable <ActivityView> Handle(ActivitiesByDateRange query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
IQueryable <ActivityView> activityViews = new EnumerableQuery <ActivityView>();
try
{
var possibleNullView = _projector.BeginReadView();
if (possibleNullView != null)
{
var view = possibleNullView.AsQueryable();
activityViews = view.Where(a =>
(
/* and, include activities that are undated... */
(!query.NoUndated || (!a.StartsOn.HasValue && !a.EndsOn.HasValue &&
(!a.OnGoing.HasValue || !a.OnGoing.Value))) &&
/* and */
(
/* On-going only */
(!a.StartsOn.HasValue && !a.EndsOn.HasValue &&
(a.OnGoing.HasValue && a.OnGoing.Value)) ||
/* End date only (with future flag) */
(!a.StartsOn.HasValue &&
(a.EndsOn.HasValue && (a.EndsOn.Value >= query.FromDate) &&
(query.IncludeFuture || (a.EndsOn < query.ToDate))) &&
(!a.OnGoing.HasValue || !a.OnGoing.Value)) ||
/* Start date and on-going */
((a.StartsOn.HasValue && (a.StartsOn.Value < query.ToDate)) &&
!a.EndsOn.HasValue && (a.OnGoing.HasValue && a.OnGoing.Value)) ||
/* Start date only */
((a.StartsOn.HasValue &&
((a.StartsOn.Value >= query.FromDate) &&
(a.StartsOn.Value < query.ToDate))) && !a.EndsOn.HasValue &&
(!a.OnGoing.HasValue || !a.OnGoing.Value)) ||
/* Start date and end date (with future flag) */
((a.StartsOn.HasValue && (a.StartsOn.Value >= query.FromDate))) &&
(a.EndsOn.HasValue && (query.IncludeFuture || (a.EndsOn < query.ToDate))) &&
(!a.OnGoing.HasValue || !a.OnGoing.Value))
)
);
}
}
finally
{
_projector.EndReadView();
}
return(activityViews.AsQueryable());
}
public void GivenEnumerableQueryWhenOfSameTypeThenAreEquivalentShouldBeTrue()
{
var enumerableQuery = new EnumerableQuery <string>(Expression.Constant("this"));
var enumerableQuerySame = new EnumerableQuery <string>(Expression.Constant("that"));
Assert.True(eq.AreEquivalent(
Expression.Constant(enumerableQuery),
Expression.Constant(enumerableQuerySame)));
}
public void GivenEnumerableQueryWhenQueryRootIsConstantExpressionThenShouldBeSet()
{
EnumerableQuery <int> query = new EnumerableQuery <int>(Expression.Constant(new int[0]));
var serialized = TestSerializer.GetSerializedFragment <Constant, ConstantExpression>(Expression.Constant(query));
var root = Expression.Constant(2);
var deserialized = serializer.Deserialize(serialized, root.ToSerializationState());
Assert.Same(deserialized, root);
}
public void NullEnumerableConstantNullExpression()
{
IQueryable <int> query = new EnumerableQuery <int>((IEnumerable <int>)null);
var exp = (ConstantExpression)query.Expression;
Assert.Same(query, exp.Value);
//FIXME: query.GetEnumerator() will now throw StackOverflowException which cannot be usefully caught.
//Issue #3546
}
public void GivenEnumerableQueryWhenOfDifferentTypeThenAreEquivalentShouldBeFalse()
{
var enumerableQuery = new EnumerableQuery <string>(Expression.Constant("this"));
var enumerableQueryDifferent = new EnumerableQuery <int>(Expression.Constant(5));
Assert.False(eq.AreEquivalent(
Expression.Constant(enumerableQuery),
Expression.Constant(enumerableQueryDifferent)));
}
public void ClusterCoordinatorGetAllCoordinatorsForDisplayReturnsExpectedData()
{
// Arrange
var coordinators = new EnumerableQuery <ClusterCoordinator>(new[]
{
new ClusterCoordinator
{
Id = _coordinatorId,
PersonId = _person1.Id,
ClusterId = _cluster1.Id,
DisasterId = _disaster1.Id,
Person = _person1,
Cluster = _cluster1,
Disaster = _disaster1
},
new ClusterCoordinator
{
Id = _notCoordinatorId,
PersonId = _person2.Id,
ClusterId = _cluster2.Id,
DisasterId = _disaster1.Id,
Person = _person2,
Cluster = _cluster2,
Disaster = _disaster1
}
});
_dataService.Setup(x => x.ClusterCoordinators).Returns(coordinators);
IList <Person> allPersonsForDisplay;
// Act
var clusterCoordinators = _clusterCoordinatorService.GetAllCoordinatorsForDisplay(_disaster1.Id,
out allPersonsForDisplay).ToList();
// Assert
Assert.IsNotNull(clusterCoordinators);
Assert.IsNotNull(allPersonsForDisplay);
Assert.AreEqual(2, clusterCoordinators.Count());
Assert.AreEqual(2, allPersonsForDisplay.Count());
const string errorMsg = "Could not find the coordinator with the ID of ";
var firstCoordinator = clusterCoordinators.FirstOrDefault(cc => cc.Id == _coordinatorId);
Assert.IsNotNull(firstCoordinator, errorMsg + _coordinatorId);
var secondCoordinator = clusterCoordinators.FirstOrDefault(cc => cc.Id == _notCoordinatorId);
Assert.IsNotNull(secondCoordinator, errorMsg + _notCoordinatorId);
Assert.AreEqual(_person1.Id, firstCoordinator.PersonId);
Assert.AreEqual(_person2.Id, secondCoordinator.PersonId);
const string personErrorMsg = "Could not find person with the ID of ";
var firstPerson = allPersonsForDisplay.FirstOrDefault(x => x.Id == _person1.Id);
Assert.IsNotNull(firstPerson, personErrorMsg + _person1.Id);
var secondPerson = allPersonsForDisplay.FirstOrDefault(x => x.Id == _person2.Id);
Assert.IsNotNull(secondPerson, personErrorMsg + _person2.Id);
}
public void isBetweenAccesibleDates_should_return_false_with_null_misc()
{
IQueryable <Misc> miscs = new EnumerableQuery <Misc>(new List <Misc>());
_miscRepository.GetAll().Returns(miscs);
var result = _accountService.isBetweenAccesibleDates();
result.Should().BeFalse();
}
public StudentsMock()
{
List = new EnumerableQuery<Student>(new List<Student>()
{
new Student {Name = "Stymie", HasBicycle = false, HomeRoomTeacher = "Mrs Thatcher"}
,
new Student {Name = "Spanky", HasBicycle = true, HomeRoomTeacher = "Mrs Thatcher"}
,
new Student {Name = "Alfalfa", HasBicycle = true, HomeRoomTeacher = "Mr Blair"}
,
new Student {Name = "Darla", HasBicycle = false, HomeRoomTeacher = "Mr Blair"}
,
new Student {Name = "Jane", HasBicycle = false, HomeRoomTeacher = "Mr Blair"}
,
new Student {Name = "Buckwheat", HasBicycle = false, HomeRoomTeacher = "Mr Major"}
});
}
