Ejemplo n.º 1
0
        public async Task EchoGrain_Timeout_Result()
        {
            grain = GrainClient.GrainFactory.GetGrain <IEchoTaskGrain>(Guid.NewGuid());

            TimeSpan  delay30 = TimeSpan.FromSeconds(30);
            TimeSpan  delay60 = TimeSpan.FromSeconds(60);
            Stopwatch sw      = new Stopwatch();

            sw.Start();
            try
            {
                int res = await grain.BlockingCallTimeoutAsync(delay60);

                Assert.Fail("BlockingCallTimeout should not have completed successfully, but returned " + res);
            }
            catch (Exception exc)
            {
                while (exc is AggregateException)
                {
                    exc = exc.InnerException;
                }
                Assert.IsInstanceOfType(exc, typeof(TimeoutException), "Received exception type: {0}", exc);
            }
            sw.Stop();
            Assert.IsTrue(TimeIsLonger(sw.Elapsed, delay30), "Elapsted time out of range: {0}", sw.Elapsed);
            Assert.IsTrue(TimeIsShorter(sw.Elapsed, delay60), "Elapsted time out of range: {0}", sw.Elapsed);
        }
        public async Task Get_ShouldReturnNotFoundIfPropertyDoesNotExists()
        {
            var result = await _propertiesControllerMock.Get(9);

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(NotFoundResult));
        }
        public async Task GetAll_ShouldReturnListOfPropertyEntitiesType()
        {
            var result = await _propertyRepositoryMock.GetAll();

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, _propertyListMock.GetType());
        }
Ejemplo n.º 4
0
        public void TestMoveIntoRightWallPlayerOne()
        {
            // Given
            var game = Match.GetInstance();

            game.StartNewGame(true);
            var map  = game.Map;
            var ship = game.GetPlayer(1).Ship;
            const ShipCommand direction = ShipCommand.MoveRight;

            // When
            while (ship.X + ship.Width < map.Width - 1)
            {
                ship.Command = direction;
                game.Update();
            }

            ship.Command = direction;
            game.Update();

            // Then
            Assert.IsInstanceOfType(map.GetEntity(map.Width - 1, ship.Y), typeof(Wall),
                                    "Rightmost tile is not a wall after ship moved into it");
            Assert.IsInstanceOfType(map.GetEntity(ship.X, ship.Y), typeof(Ship),
                                    "Leftmost ship tile is missing after moving into a right wall");
            Assert.IsInstanceOfType(map.GetEntity(ship.X + 1, ship.Y), typeof(Ship),
                                    "Center ship tile is missing after moving into a right wall");
            Assert.IsInstanceOfType(map.GetEntity(ship.X + 2, ship.Y), typeof(Ship),
                                    "Rightmost ship tile is missing after moving into a right wall");
            Assert.AreEqual(map.Width - 4, ship.X,
                            "Ship x is not " + (map.Width - 4) + "as expected after moving into a right wall");
        }
Ejemplo n.º 5
0
        public async Task Constructor_Bad_Await()
        {
            try
            {
                int id = random.Next();
                IBadConstructorTestGrain grain = GrainClient.GrainFactory.GetGrain <IBadConstructorTestGrain>(id);

                await grain.DoSomething();

                Assert.Fail("Expected ThrowSomething call to fail as unable to Activate grain");
            }
            catch (TimeoutException te)
            {
                Console.WriteLine("Received timeout: " + te);
                throw; // Fail test
            }
            catch (Exception exc)
            {
                Console.WriteLine("Received exception: " + exc);
                Exception e = exc.GetBaseException();
                Console.WriteLine("Nested exception type: " + e.GetType().FullName);
                Console.WriteLine("Nested exception message: " + e.Message);
                Assert.IsInstanceOfType(e, typeof(Exception),
                                        "Did not get expected exception type returned: " + e);
                Assert.IsNotInstanceOfType(e, typeof(InvalidOperationException),
                                           "Did not get expected exception type returned: " + e);
                Assert.IsTrue(e.Message.Contains("Constructor"),
                              "Did not get expected exception message returned: " + e.Message);
            }
        }
Ejemplo n.º 6
0
        public async Task GetAll_ShouldReturnListOfBrokerEntitiesType()
        {
            var result = await _brokerRepositoryMock.GetAll();

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, _brokerListMock.GetType());
        }
Ejemplo n.º 7
0
        public void TestShipCanDestroyOwnShields()
        {
            // Given
            var game = Match.GetInstance();

            game.StartNewGame(true);
            var map    = game.Map;
            var player = game.GetPlayer(1);
            var ship   = player.Ship;

            ship.Command = ShipCommand.BuildShield;
            game.Update();

            // When
            ship.Command = ShipCommand.Shoot;
            game.Update();

            // Then
            Assert.IsInstanceOfType(map.GetEntity(ship.X, ship.Y - 1), typeof(Shield),
                                    "Left shield tile is missing");
            Assert.IsNull(map.GetEntity(ship.X + 1, ship.Y - 1),
                          "Center shield tile was not destroyed");
            Assert.IsInstanceOfType(map.GetEntity(ship.X + 2, ship.Y - 1), typeof(Shield),
                                    "Right shield tile is missing");
        }
        public async Task GetAll_ShouldReturnListOfPropertyListItemDTOType()
        {
            var result = await _propertyServiceMock.GetAll();

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, _propertyListItemDtoMock.GetType());
        }
Ejemplo n.º 9
0
        public void CastGrainRefUpCastFromGrandchild()
        {
            // GeneratorTestDerivedGrain1Reference derives from GeneratorTestGrainReference
            // GeneratorTestDerivedGrain2Reference derives from GeneratorTestGrainReference
            // GeneratorTestDerivedDerivedGrainReference derives from GeneratorTestDerivedGrain2Reference

            GrainReference cast;
            GrainReference grain = (GrainReference)GrainClient.GrainFactory.GetGrain <IGeneratorTestDerivedDerivedGrain>(GetRandomGrainId());

            // Parent
            cast = (GrainReference)grain.AsReference <IGeneratorTestDerivedGrain2>();
            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestDerivedDerivedGrain));
            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestDerivedGrain2));
            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestGrain));

            // Cross-cast outside the inheritance hierarchy should not work
            Assert.IsNotInstanceOfType(cast, typeof(IGeneratorTestDerivedGrain1));

            // Grandparent
            cast = (GrainReference)grain.AsReference <IGeneratorTestGrain>();
            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestDerivedDerivedGrain));
            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestGrain));

            // Cross-cast outside the inheritance hierarchy should not work
            Assert.IsNotInstanceOfType(cast, typeof(IGeneratorTestDerivedGrain1));
        }
        public void AddItemToBasket_GivenUnavailableStock_ReturnsBadRequest()
        {
            // Arrange
            var userId = 1;

            this.basketService.GetByUserId(userId).Returns(new Basket());
            var basketItem = new BasketItem();

            this.mapperService.Map(Arg.Any <Item>()).Returns(basketItem);

            const int itemId   = 1;
            const int quantity = 2;

            this.itemService.Get(itemId).Returns(new Item {
                Stock = 1
            });

            // Act
            var actionResult = controller.AddBasketEntry(userId, new BasketEntry {
                ItemId = itemId, Quantity = quantity
            });

            // Assert
            Assert.IsInstanceOfType(actionResult, typeof(BadRequestErrorMessageResult));
        }
        public void Checkout_ReturnsInvoiceOk()
        {
            // Arrange
            var userId = 1;

            this.userService.Get("TestUser").Returns(new User {
                Id = userId
            });

            var basket = new Basket();

            basket.Add(new BasketItem {
                ItemId = 2
            });

            this.basketService.GetByUserId(userId).Returns(basket);
            this.itemService.Get(2).Returns(new Item {
                Id = 2, Stock = 4
            });

            // Act
            var actionResult = controller.Checkout("TestUser");

            // Assert
            Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <Invoice>));
        }
        public void MustPopulateObject()
        {
            var obj1 = new TestContrato()
            {
                Id             = 1,
                Contrato_Id    = "string",
                DateCreated    = DateTime.Today.AddDays(-10),
                NumeroContrato = "string",
                NumeroProposta = "string",
                TitularId      = 2
            };
            var obj2 = new TestContrato2()
            {
                Id              = 2,
                NumeroContrato  = "Alterado",
                NumeroContrato2 = "Alterado2",
                TitularId       = null
            };

            var result = obj1.PopulateProperties(obj2);

            Assert.IsInstanceOfType(result, typeof(TestContrato));

            var resultType = (TestContrato)result;

            resultType.Id.ShouldBe(obj2.Id);
            resultType.NumeroContrato.ShouldBe(obj2.NumeroContrato);

            obj2.NumeroProposta.ShouldBeNull();
            resultType.NumeroProposta.ShouldBeEqual(obj2.NumeroProposta);

            resultType.DateCreated.ShouldBe(obj1.DateCreated);
        }
Ejemplo n.º 13
0
        public void EchoGrain_Timeout_Wait()
        {
            grain = GrainClient.GrainFactory.GetGrain <IEchoTaskGrain>(Guid.NewGuid());

            TimeSpan  delay30 = TimeSpan.FromSeconds(30); // grain call timeout (set in config)
            TimeSpan  delay45 = TimeSpan.FromSeconds(45);
            TimeSpan  delay60 = TimeSpan.FromSeconds(60);
            Stopwatch sw      = new Stopwatch();

            sw.Start();
            Task <int> promise = grain.BlockingCallTimeoutAsync(delay60);
            bool       ok      = promise.ContinueWith(t =>
            {
                if (!t.IsFaulted)
                {
                    Assert.Fail("BlockingCallTimeout should not have completed successfully");
                }

                Exception exc = t.Exception;
                while (exc is AggregateException)
                {
                    exc = exc.InnerException;
                }
                Assert.IsInstanceOfType(exc, typeof(TimeoutException), "Received exception type: {0}", exc);
            }).Wait(delay45);

            sw.Stop();
            Assert.IsTrue(ok, "Wait should not have timed-out. The grain call should have time out.");
            Assert.IsTrue(TimeIsLonger(sw.Elapsed, delay30), "Elapsted time out of range: {0}", sw.Elapsed);
            Assert.IsTrue(TimeIsShorter(sw.Elapsed, delay60), "Elapsted time out of range: {0}", sw.Elapsed);
        }
        public async Task GetAll_ShouldReturnListOfPropertyEntityType()
        {
            var result = await _propertiesControllerMock.Get() as OkNegotiatedContentResult <List <PropertyListItemDTO> >;

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.Content);
            Assert.IsInstanceOfType(result.Content, _propertyListItemDTOMock.GetType());
        }
Ejemplo n.º 15
0
        public async Task GetAll_ShouldReturnListOfBrokerDTOEntityType()
        {
            var result = await _brokerControllerMock.Get() as OkNegotiatedContentResult <List <BrokerDTO> >;

            Assert.IsNotNull(result);
            Assert.IsNotNull(result.Content);
            Assert.IsInstanceOfType(result.Content, _brokerDTOListMock.GetType());
        }
Ejemplo n.º 16
0
        public void CastGrainRefCastFromMyType()
        {
            GrainReference grain = (GrainReference)GrainClient.GrainFactory.GetGrain <ISimpleGrain>(random.Next(), SimpleGrain.SimpleGrainNamePrefix);
            GrainReference cast  = (GrainReference)grain.AsReference <ISimpleGrain>();

            Assert.IsInstanceOfType(cast, grain.GetType());
            Assert.IsInstanceOfType(cast, typeof(ISimpleGrain));
        }
Ejemplo n.º 17
0
        public void CastGrainRefUpCastFromChild()
        {
            // GeneratorTestDerivedGrain1Reference extends GeneratorTestGrainReference
            GrainReference grain = (GrainReference)GrainClient.GrainFactory.GetGrain <IGeneratorTestDerivedGrain1>(GetRandomGrainId());
            GrainReference cast  = (GrainReference)grain.AsReference <IGeneratorTestGrain>();

            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestDerivedGrain1));
            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestGrain));
        }
Ejemplo n.º 18
0
        public void Serialization_ValueTypePhase2()
        {
            ValueTypeTestData data = new ValueTypeTestData(4);

            object copy = SerializationManager.RoundTripSerializationForTesting(data);

            Assert.IsInstanceOfType(copy, typeof(ValueTypeTestData), "Deserialized result is of wrong type");
            Assert.AreEqual <int>(4, ((ValueTypeTestData)copy).GetValue(), "Deserialized result is incorrect");
        }
Ejemplo n.º 19
0
        public void Serialization_ValueTypePhase1()
        {
            ValueTypeTestData data = new ValueTypeTestData(4);

            object obj = SerializationManager.DeepCopy(data);

            Assert.IsInstanceOfType(obj, typeof(ValueTypeTestData), "Deserialized result is of wrong type");
            Assert.AreEqual <int>(4, ((ValueTypeTestData)obj).GetValue(), "Deserialized result is incorrect");
        }
Ejemplo n.º 20
0
        public async Task PubSub_Store_WriteError()
        {
            SetErrorInjection(PubSubStoreProviderName, ErrorInjectionPoint.BeforeWrite);

            var exception = await Xunit.Assert.ThrowsAsync <OrleansException>(() =>
                                                                              Test_PubSub_Stream(StreamProviderName, StreamId));

            Assert.IsInstanceOfType(exception.InnerException, typeof(StorageProviderInjectedError));
        }
        public void GetBasket_GivenAnUnknownUserName_ReturnsBasketOk()
        {
            // Arrange
            this.userService.Get("TestUser").Returns(new User());
            // Act
            var actionResult = controller.GetBasket("Unknown User");

            // Assert
            Assert.IsInstanceOfType(actionResult, typeof(BadRequestErrorMessageResult));
        }
        public void GetBasket_ReturnsBasketOk()
        {
            // Arrange
            this.userService.Get("TestUser").Returns(new User());
            // Act
            var actionResult = controller.GetBasket("TestUser");

            // Assert
            Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <Basket>));
        }
Ejemplo n.º 23
0
        public void Get_Returns_Ok()
        {
            // Arrange

            // Act
            var actionResult = controller.Get();

            // Assert
            Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <IEnumerable <Item> >));
        }
Ejemplo n.º 24
0
        public void ChangePasswordSuccess_ReturnsView()
        {
            // Arrange
            AccountController controller = GetAccountController();

            // Act
            ActionResult result = controller.ChangePasswordSuccess();

            // Assert
            Assert.IsInstanceOfType(result, typeof(ViewResult));
        }
Ejemplo n.º 25
0
        public void LogOn_Get_ReturnsView()
        {
            // Arrange
            AccountController controller = GetAccountController();

            // Act
            ActionResult result = controller.LogOn();

            // Assert
            Assert.IsInstanceOfType(result, typeof(ViewResult));
        }
Ejemplo n.º 26
0
        public void Register_Get_ReturnsView()
        {
            // Arrange
            AccountController controller = GetAccountController();

            // Act
            ActionResult result = controller.Register();

            // Assert
            Assert.IsInstanceOfType(result, typeof(ViewResult));
            Assert.AreEqual(10, ((ViewResult)result).ViewData["PasswordLength"]);
        }
Ejemplo n.º 27
0
        public void CastInternalCastFromMyType()
        {
            var            serviceName = typeof(SimpleGrain).FullName;
            GrainReference grain       = (GrainReference)GrainClient.GrainFactory.GetGrain <ISimpleGrain>(random.Next(), SimpleGrain.SimpleGrainNamePrefix);

            IAddressable cast = GrainReference.CastInternal(
                typeof(ISimpleGrain),
                (GrainReference gr) => { throw new InvalidOperationException("Should not need to create a new GrainReference wrapper"); },
                grain,
                Utils.CalculateIdHash(serviceName));

            Assert.IsInstanceOfType(cast, typeof(ISimpleGrain));
        }
Ejemplo n.º 28
0
        public void CastInternalCastUpFromChild()
        {
            // GeneratorTestDerivedGrain1Reference extends GeneratorTestGrainReference
            GrainReference grain = (GrainReference)GrainClient.GrainFactory.GetGrain <IGeneratorTestDerivedGrain1>(GetRandomGrainId());

            var          serviceName = typeof(GeneratorTestGrain).FullName;
            IAddressable cast        = GrainReference.CastInternal(
                typeof(IGeneratorTestGrain),
                (GrainReference gr) => { throw new InvalidOperationException("Should not need to create a new GrainReference wrapper"); },
                grain,
                Utils.CalculateIdHash(serviceName));

            Assert.IsInstanceOfType(cast, typeof(IGeneratorTestGrain));
        }
Ejemplo n.º 29
0
        public void LogOff_LogsOutAndRedirects()
        {
            // Arrange
            AccountController controller = GetAccountController();

            // Act
            ActionResult result = controller.LogOff();

            // Assert
            Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
            RedirectToRouteResult redirectResult = (RedirectToRouteResult)result;

            Assert.AreEqual("Home", redirectResult.RouteValues["controller"]);
            Assert.AreEqual("Index", redirectResult.RouteValues["action"]);
            Assert.IsTrue(((MockFormsAuthenticationService)controller.FormsService).SignOut_WasCalled);
        }
Ejemplo n.º 30
0
        private void RunGrainReferenceSerializationTest <TGrainInterface>()
        {
            var counters = new List <CounterStatistic>
            {
                CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_SERIALIZATION),
                CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_DESERIALIZATION),
                CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_DEEPCOPIES)
            };

            // Get the (generated) grain reference implementation for a particular grain interface type.
            var grainReference = this.GetGrainReference <TGrainInterface>();

            // Get the current value of each of the fallback serialization counters.
            var initial = counters.Select(_ => _.GetCurrentValue()).ToList();

            // Serialize and deserialize the grain reference.
            var writer = new BinaryTokenStreamWriter();

            SerializationManager.Serialize(grainReference, writer);
            var deserialized = SerializationManager.Deserialize(new BinaryTokenStreamReader(writer.ToByteArray()));
            var copy         = (GrainReference)SerializationManager.DeepCopy(deserialized);

            // Get the final value of the fallback serialization counters.
            var final = counters.Select(_ => _.GetCurrentValue()).ToList();

            // Ensure that serialization was correctly performed.
            Assert.IsInstanceOfType(
                deserialized,
                grainReference.GetType(),
                "Deserialized GrainReference type should match original type");
            var deserializedGrainReference = (GrainReference)deserialized;

            Assert.IsTrue(
                deserializedGrainReference.GrainId.Equals(grainReference.GrainId),
                "Deserialized GrainReference should have same GrainId as original value.");
            Assert.IsInstanceOfType(copy, grainReference.GetType(), "DeepCopy GrainReference type should match original type");
            Assert.IsTrue(
                copy.GrainId.Equals(grainReference.GrainId),
                "DeepCopy GrainReference should have same GrainId as original value.");

            // Check that the counters have not changed.
            var initialString = string.Join(",", initial);
            var finalString   = string.Join(",", final);

            Assert.AreEqual(initialString, finalString, "GrainReference serialization should not use fallback serializer.");
        }