public void QueryCritter_SelectIntThenSum()
{
var expected = CritterEntities.Select(x => x.Name.Length).Sum();
var actual = Client.Query <ICritter>().Select(x => x.Name.Length).Sum();
Assert.That(actual, Is.EqualTo(expected));
}
public void QueryCritter_SelectToStringObjectDictionary_ReturnsCorrectValues()
{
Func <Critter, Dictionary <string, object> > selector = x =>
new Dictionary <string, object>
{
{ "critterId", x.Id },
{ "critterName", x.Name }
};
var expected = CritterEntities
.Select(
selector)
.First();
Expression <Func <ICritter, Dictionary <string, object> > > expression = x =>
new Dictionary <string, object>
{
{ "critterId", x.Id },
{ "critterName", x.Name }
};
var actual =
Client.Query <ICritter>()
.Select(
expression)
.First();
AssertSequenceEqualsAndCountIsGreaterThanZero(actual, expected);
}
public void PostCritterWithSubscription_RunsOnDeserializationHook()
{
const string critterName = "Postal critter";
var critter = (ICritter)Client.Post <ICritter>(
x =>
{
x.Subscriptions.Add(new SubscriptionForm
{
Model = new WeaponModelForm {
Name = "blah"
},
Sku = "haha",
StartsOn = DateTime.UtcNow
});
x.Name = critterName;
});
Assert.That(critter.Name, Is.EqualTo(critterName));
Assert.That(critter.Subscriptions.Count, Is.EqualTo(1));
var critterEntity = CritterEntities.First(x => x.Id == critter.Id);
Assert.That(critterEntity.Subscriptions[0].Critter, Is.EqualTo(critterEntity));
}
public void QueryCritter_SelectDoubleThenSum()
{
var expected = CritterEntities.Select(x => (double)x.Id).Sum();
var actual = Client.Query <ICritter>().Select(x => (double)x.Id).Sum();
Assert.That(actual, Is.EqualTo(expected));
}
public void QueryCritter_GetSumOfNullableInt()
{
var expected = CritterEntities.Sum(x => (int?)x.Id);
var actual = Client.Query <ICritter>().Sum(x => (int?)x.Id);
Assert.That(actual, Is.EqualTo(expected));
}
public void QueryCritter_GroupByThenSelectAnonymousClass_ReturnsCorrectValues()
{
Repository.CreateRandomData();
// Just take some random critter
// Search by its name
var expected =
CritterEntities
.Where(x => x.Id % 3 > 0)
.GroupBy(x => x.Farm.Id)
.Select(
x => new
{
x.Key,
Count = x.Count(),
WeaponSum = x.Sum(y => y.Weapons.Sum(z => z.Strength))
})
.Take(1)
.ToList();
var actual =
Client.Query <ICritter>()
.Where(x => x.Id % 3 > 0)
.GroupBy(x => x.Farm.Id)
.Select(
x => new
{
x.Key,
Count = x.Count(),
WeaponSum = x.Sum(y => y.Weapons.Sum(z => z.Strength))
})
.Take(1)
.ToList();
AssertSequenceEqualsAndCountIsGreaterThanZero(actual, expected);
}
public void QueryCritter_GetSumOfDecimal()
{
var expected = CritterEntities.Sum(x => (decimal)x.Id);
var actual = Client.Query <ICritter>().Sum(x => (decimal)x.Id);
Assert.That(actual, Is.EqualTo(expected));
}
public void QueryCritter_GetSumOfInt()
{
var expected = CritterEntities.Sum(x => x.Name.Length);
var actual = Client.Query <ICritter>().Sum(x => x.Name.Length);
Assert.That(actual, Is.EqualTo(expected));
}
public async Task FutureMax_ReturnsCorrectResult()
{
var expected = CritterEntities.Max(x => x.Id);
var result = await Client.Critters.Query().Future(x => x.Max(y => y.Id));
Assert.That(result, Is.EqualTo(expected));
}
public void QueryCritter_IdInList_ReturnsCorrectCritters()
{
Repository.CreateRandomData(critterCount: 10);
var ids = CritterEntities.Skip(4).Select(x => x.Id).Take(5).ToList();
TestQuery <ICritter, Critter>(x => ids.Contains(x.Id), x => ids.Contains(x.Id), expectedResultCount: 5);
}
public void GetResourceById_UsingClientRepository_ReturnsResource()
{
var critterEntity = CritterEntities.First();
var critterResource = Client.Critters.Get(critterEntity.Id);
Assert.That(critterResource, Is.Not.Null);
}
public void QueryCritter_WithNameEquals_ReturnsCorrectResult()
{
var nameOfFirstCritter = CritterEntities.First().Name;
var fetchedCritters = Client.Query <ICritter>(x => x.Name == nameOfFirstCritter);
Assert.That(fetchedCritters.Any(x => x.Name == nameOfFirstCritter));
}
public void Query_ExtendedResources_WrapsResourcesCorrectly_WhenUsingToArray()
{
var critterEntities = CritterEntities.Take(10);
var critters = Client.Critters.Query <IDecoratedCritter>().Take(10).ToArray();
Assert.That(critterEntities.Select(x => x.Id), Is.EquivalentTo(critters.Select(x => x.Id)));
}
public void QueryCritter_GroupByThenSelectAnonymousClassThenOrderBy_ReturnsCorrectValues()
{
// Just take some random critter
// Search by its name
var expected =
CritterEntities
.GroupBy(x => x.Name.Substring(0, 1))
.Select(
x => new
{
x.Key,
Count = x.Count(),
WeaponSum = x.Sum(y => y.Weapons.Sum(z => z.Strength))
})
.OrderByDescending(x => x.Count)
.Take(10)
.ToList();
var actual =
Client.Query <ICritter>()
.GroupBy(x => x.Name.Substring(0, 1))
.Select(
x => new
{
x.Key,
Count = x.Count(),
WeaponSum = x.Sum(y => y.Weapons.Sum(z => z.Strength))
})
.OrderByDescending(x => x.Count)
.Take(10)
.ToList();
AssertSequenceEqualsAndCountIsGreaterThanZero(actual, expected);
}
public async Task ToQueryResultAsync_ReturnsCorrectResult()
{
var firstCritterId = CritterEntities.First().Id;
var result = await Client.Critters.Query().Where(x => x.Id == firstCritterId).ToQueryResultAsync();
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0].Id, Is.EqualTo(firstCritterId));
}
public void SimpleQueryTest()
{
var musicalCritterId = CritterEntities.OfType <MusicalCritter>().First().Id;
var musicalCritter = ResourceFetcherExtensions.Get <ICritter>(Client, BaseUri + "critters/" + musicalCritterId);
Assert.That(musicalCritter, Is.AssignableTo <IMusicalCritter>());
}
public void Query_SelectObjectArray_IsSuccessful()
{
var results = Client.Critters.Query().Select(x => new object[] { x.Id, x.Guid, x.Hat }).ToList();
var comparableResults = results.Select(x => new { Id = (int)x[0], Guid = (Guid)x[1], HatId = ((IHat)x[2]).Id }).ToList();
var expected = CritterEntities.Select(x => new { x.Id, x.Guid, HatId = x.Hat.Id });
CollectionAssert.AreEqual(expected, comparableResults);
}
public void GetMusicalCritter()
{
var musicalCritterId = CritterEntities.OfType <MusicalCritter>().First().Id;
var musicalCritter = Client.Get <ICritter>(BaseUri + "critters/" + musicalCritterId);
Assert.That(musicalCritter, Is.AssignableTo <IMusicalCritter>());
}
public void Select_WithClientServerSplit_CallingNewOfTypeOnlyAvailableOnClient_IsSuccessful()
{
var expected =
CritterEntities.Select(x => new ClientSideClass(x.Id, x.Name)).ToList();
var actual =
Client.Critters.Select(x => new ClientSideClass(x.Id, x.Name)).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void QueryCritter_CastToMusicalCritterWithEqualsOperator_ReturnsCorrectMusicalCritter()
{
var firstMusicalCritter =
CritterEntities.OfType <MusicalCritter>().First();
var bandName = firstMusicalCritter.BandName;
TestQuery <ICritter, Critter>(x => x is IMusicalCritter && ((IMusicalCritter)x).BandName == bandName,
x => x is MusicalCritter && ((MusicalCritter)x).BandName == bandName);
}
public void Select_WithClientServerSplit_CallingMethodOnlyAvailableToClient_IsSuccessful_UsingFirstProjection()
{
var expected =
CritterEntities.Select(x => new ClientSideClass(x.Id, x.Name + "|" + SomeCrazyMethod(x.Name))).First();
var actual =
Client.Critters.Select(x => new ClientSideClass(x.Id, x.Name + "|" + SomeCrazyMethod(x.Name))).First();
Assert.That(actual, Is.EqualTo(expected));
}
public void QueryCritter_AnyWithExistingName_ReturnsTrue()
{
// Just take some random critter
var critter = CritterEntities.First();
var hasCritterWithGuid =
Client.Critters.Query().Any(x => x.Name == critter.Name);
Assert.That(hasCritterWithGuid, Is.True);
}
public void QueryCritter_WhereThenSelectSingleProperty_ReturnsCorrectValues()
{
// Just take some random critter
// Search by its name
var expected = CritterEntities.OrderBy(x => x.Name).Select(x => x.Name).Take(10000).ToList();
var actual =
Client.Query <ICritter>().OrderBy(x => x.Name).Select(x => x.Name).Take(10000).ToList().ToList();
Assert.That(actual, Is.EqualTo(expected));
}
public void QueryCritter_WhereSingle_ReturnsCorrectCritter()
{
// Just take some random critter
var critter = CritterEntities.Skip(1).Take(1).First();
// Search by its name
var critterResource =
Client.Query <ICritter>().Single(x => x.Name == critter.Name && x.Guid == critter.Guid);
Assert.That(critterResource.Id, Is.EqualTo(critter.Id));
}
public void UsesCustomSetterForAbsoluteFileUrl_OnPatch()
{
var critter = Client.Critters.First();
critter = Client.Critters.Patch(critter, x => x.AbsoluteImageUrl = "http://test:80/new-image.png");
Assert.That(critter.AbsoluteImageUrl, Is.EqualTo("http://test:80/new-image.png"));
var critterEntity = CritterEntities.First(x => x.Id == critter.Id);
Assert.That(critterEntity.RelativeImageUrl, Is.EqualTo("/new-image.png"));
}
public void QuerySubclassedMusicalCritter_WhereFirst_ReturnsCorrectMusicalCritter()
{
// Just take some random critter
var critter = CritterEntities.OfType <MusicalCritter>().Take(1).First();
// Search by its name
var critterResource =
Client.Query <IMusicalCritter>().First(
x => x.Name == critter.Name && x.Guid == critter.Guid && x.BandName == critter.BandName);
Assert.That(critterResource.Id, Is.EqualTo(critter.Id));
}
public void QueryResourceWithNonExpandedEnumerable_ReturnsLazyItems()
{
Repository.CreateRandomData(critterCount: 20);
var farms = Client.Farms.Query().ToList();
Assert.That(farms.All(x => x.MusicalCritters is LazyListProxy <IMusicalCritter>));
var musicalCritters = farms.SelectMany(x => x.MusicalCritters).ToList();
Assert.That(musicalCritters.Select(x => x.Id).OrderBy(x => x),
Is.EquivalentTo(CritterEntities.OfType <MusicalCritter>().Select(x => x.Id)));
}
public void Select_WithClientServerSplit_UsingLocallyExecutedConcatMethod_IsSuccessful()
{
var expected =
CritterEntities.Select(
x => new ClientSideClass(x.Id, x.Name.ToUpper() + "|" + SomeCrazyMethod(x.Name.ToLower()))).ToList();
var actual =
Client.Critters.Select(
x => new ClientSideClass(x.Id, x.Name.ToUpper() + "|" + SomeCrazyMethod(x.Name.ToLower()))).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void UsesCustomSetterForAbsoluteFileUrl_OnPost()
{
var critter = Client.Critters.Post(new CritterForm()
{
AbsoluteImageUrl = "http://test:80/holala.png"
});
Assert.That(critter.AbsoluteImageUrl, Is.EqualTo("http://test:80/holala.png"));
var critterEntity = CritterEntities.First(x => x.Id == critter.Id);
Assert.That(critterEntity.RelativeImageUrl, Is.EqualTo("/holala.png"));
}
public void QueryResourceWithShallowExpandedEnumerable_ReturnsExpandedListOfReferences()
{
Repository.CreateRandomData(critterCount: 20);
var farms = Client.Farms.Query().ExpandShallow(x => x.MusicalCritters).ToList();
Assert.That(farms.All(x => x.MusicalCritters.IsLoaded()), Is.True);
var musicalCritters = farms.SelectMany(x => x.MusicalCritters).ToList();
Assert.That(farms.SelectMany(x => x.MusicalCritters).All(x => x.IsLoaded()), Is.False);
Assert.That(musicalCritters.Select(x => x.Id).OrderBy(x => x),
Is.EquivalentTo(CritterEntities.OfType <MusicalCritter>().Select(x => x.Id)));
}
