Exemple #1
0
        public void GetResourceById_UsingClientRepository_ReturnsResource()
        {
            var critterEntity   = CritterEntities.First();
            var critterResource = Client.Critters.Get(critterEntity.Id);

            Assert.That(critterResource, Is.Not.Null);
        }
Exemple #2
0
        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));
        }
Exemple #3
0
        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));
        }
Exemple #4
0
        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));
        }
Exemple #5
0
        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);
        }
Exemple #6
0
        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"));
        }
Exemple #7
0
        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"));
        }
Exemple #8
0
        public void QueryCritter_WithNameEqualsOrNameEqualsSomethingElse_ReturnsCorrectResult()
        {
            var nameOfFirstCritter  = CritterEntities.First().Name;
            var nameOfSecondCritter =
                Repository.List <Critter>().Skip(1).First().Name;

            var critters =
                Client.Query <ICritter>(x => x.Name == nameOfFirstCritter || x.Name == nameOfSecondCritter);

            Assert.That(critters.Any(x => x.Name == nameOfFirstCritter));
            Assert.That(critters.Any(x => x.Name == nameOfSecondCritter));
        }
Exemple #9
0
        public void QueryCritter_FirstLazy_ReturnsLazyCritter()
        {
            var randCritter = Repository.CreateRandomCritter(new Random());
            var expected    = CritterEntities.First(x => x.Id == randCritter.Id);
            var lazyCritter = Client.Query <ICritter>()
                              .Where(x => x.Id == randCritter.Id)
                              // Explicit call to FirstLazy should succeed.
                              .FirstLazy();
            var beforeLoadUri = ((IHasResourceUri)lazyCritter).Uri;
            var predicate     = $"$filter=id+eq+{randCritter.Id}";

            Assert.That(beforeLoadUri, Contains.Substring(predicate));
            Console.WriteLine(beforeLoadUri);
            // Should load uri when retrieving name
            var name         = lazyCritter.Name;
            var afterLoadUri = ((IHasResourceUri)lazyCritter).Uri;

            Assert.That(afterLoadUri, Does.Not.Contain(predicate));
            Console.WriteLine(afterLoadUri);
            Assert.That(name, Is.EqualTo(expected.Name));
        }
Exemple #10
0
        public void GetResourceById_WithExpandedProperty_ReturnedResourceHasExpandedProperty()
        {
            // TOOD: Get single item with expand is not yet implemented in client
            var critter = Client.Get <ICritter>(((IHasResourceUri)Client.Critters.GetLazy(CritterEntities.First().Id)).Uri,
                                                RequestOptions.Create <ICritter>(x => x.Expand(y => y.Weapons)));

            Assert.That(critter.Weapons.IsLoaded());
        }
Exemple #11
0
 public void QueryAgainstEntityWithRepositoryProperty_WithPredicateOnRepositoryProperty()
 {
     var firstCritterName = CritterEntities.First().Name;
     var farm             = Client.Farms.Where(x => x.Critters.Any(y => y.Name == firstCritterName)).ToList();
 }