public void EngineShouldCreateRespinBonusInstance(int level)
        {
            var config     = new Configuration();
            var spinResult = GenerateWithRespinSpinResult(level);

            Assert.IsNotNull(RespinBonusEngine.CreateRespinBonus(spinResult));
        }
        public void EngineShouldWriteXmlOfrespinBonusResultXml(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);
            var xElement          = respinBonusResult.ToXElement();

            Assert.DoesNotThrow(() =>
            {
                var responseXml = new RespinBonusXml();
                using (var xmlReader = xElement.CreateReader())
                {
                    responseXml.ReadXml(xmlReader);
                }

                using (var memStream = new MemoryStream())
                    using (var xmlWriter = XmlWriter.Create(memStream, new XmlWriterSettings()
                    {
                        ConformanceLevel = ConformanceLevel.Auto
                    }))
                    {
                        xmlWriter.WriteStartElement("bonus");
                        responseXml.WriteXml(xmlWriter);
                    }
            });
        }
        public string EngineShouldCreateCorrectRespinWheel(string wheelString, string newWheelString, int level)
        {
            var config  = new Configuration();
            var spinBet = MainGameEngine.GenerateSpinBet(new RequestContext <SpinArgs>("", "", PlatformType.Web)
            {
                GameSetting = new Model.Entity.GameSetting {
                    GameSettingGroupId = 0
                },
                Currency = new Model.Entity.Currency {
                    Id = 0
                },
                Parameters = new SpinArgs
                {
                    LineBet    = 1,
                    Multiplier = 1
                }
            });

            var wheel          = new Wheel(Game.WheelWidth, Game.WheelHeight, wheelString.ToFormattedWheelString());
            var winPositions   = MainGameEngine.GenerateWinPositions(config.Payline, config.PayTable, wheel, spinBet.LineBet, spinBet.Lines, spinBet.Multiplier);
            var stackedReels   = MainGameEngine.GetStackedReels(wheel, config.PayTable);
            var bonusPositions = MainGameEngine.GenerateBonusPositions(stackedReels);
            var spinResult     = new SpinResult(spinBet, wheel, winPositions, bonusPositions);
            var newWheel       = new Wheel(Game.WheelWidth, Game.WheelHeight, newWheelString.ToFormattedWheelString());
            var generatedWheel = RespinBonusEngine.GenerateRespinWheel(spinResult, newWheel);

            return(string.Join(",", generatedWheel.Reels.SelectMany(symbol => symbol)));
        }
        public void EngineShouldCreateRespinResult(int gameId, int level)
        {
            var config         = new Configuration();
            var spinResult     = GenerateWithRespinSpinResult(level);
            var requestContext = GetMockBonusRequestContext(0, gameId);

            Assert.DoesNotThrow(() => RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config));
        }
        public void EngineShouldCreateRespinBonusWithTransactionId(int level)
        {
            var config      = new Configuration();
            var spinResult  = GenerateWithBonusSpinResult(level);
            var respinBonus = RespinBonusEngine.CreateRespinBonus(spinResult);

            Assert.IsTrue(respinBonus.SpinTransactionId == spinResult.TransactionId);
        }
        public void EngineShouldCreateRespinBonusWithValidGuid(int level)
        {
            var config      = new Configuration();
            var spinResult  = GenerateWithRespinSpinResult(level);
            var respinBonus = RespinBonusEngine.CreateRespinBonus(spinResult);

            Assert.IsTrue(!string.IsNullOrWhiteSpace(respinBonus.Guid.ToString()));
        }
        public void EngineShouldCreateRespinBonusWithGameResult(int level)
        {
            var config      = new Configuration();
            var spinResult  = GenerateWithBonusSpinResult(level);
            var respinBonus = RespinBonusEngine.CreateRespinBonus(spinResult);

            Assert.AreSame(spinResult, respinBonus.GameResult);
            Assert.AreSame(spinResult, respinBonus.SpinResult);
        }
        public void EngineShouldCompleteRespinBonusWithZeroCounter(int gameId, int level)
        {
            var config         = new Configuration();
            var spinResult     = GenerateWithRespinSpinResult(level);
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var respinBonus    = RespinBonusEngine.CreateRespinBonus(spinResult);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);

            respinBonus.UpdateBonus(spinResult);

            Assert.IsTrue(respinBonus.IsCompleted);
        }
示例#9
0
        public void SpinResultShouldHaveSameRespinBonusDetailsOnResultUpdate(int level)
        {
            var spinResult  = GenerateWithRespinSpinResult(level);
            var respinBonus = RespinBonusEngine.CreateRespinBonus(spinResult);

            respinBonus.UpdateBonus(spinResult);
            spinResult.UpdateBonus(respinBonus);

            var isEqualBonusId   = spinResult.BonusElement.Id == respinBonus.Id;
            var isEqualBonusGuid = spinResult.BonusElement.Value == respinBonus.Guid.ToString("N");

            Assert.IsTrue(isEqualBonusId && isEqualBonusGuid);
        }
        public void EngineShouldCreateRespinBonusResultWithSameSpinTransactionId(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);

            Assert.IsTrue(respinBonusResult.SpinTransactionId == bonus.SpinTransactionId);
        }
        public void EngineShouldCreateRespinBonusResultWithSameGameResultAndBonus(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);

            Assert.AreSame(respinBonusResult.Bonus, bonus);
        }
        public void EngineShouldCreateBonusResponseXmlOfrespinBonusResult(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);
            var responseXml       = respinBonusResult.ToResponseXml(ResponseXmlFormat.History);

            Assert.IsNotNull(responseXml);
        }
        public void EngineShouldCreateBonusXElementOfrespinBonusResult(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);
            var xElement          = respinBonusResult.ToXElement();

            Assert.IsNotNull(xElement);
        }
        public void EngineShouldReadResponseXmlOfrespinBonusResult(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);
            var xElement          = respinBonusResult.ToXElement();

            Assert.DoesNotThrow(() =>
            {
                using (var xmlReader = xElement.CreateReader())
                {
                    var responseXml = new RespinBonusXml();
                    responseXml.ReadXml(xmlReader);
                }
            });
        }
        public void EngineShouldCopyBonusValuesFromResultToXml(int gameId, int level)
        {
            var config         = new Configuration();
            var requestContext = GetMockBonusRequestContext(0, gameId);
            var spinResult     = GenerateWithRespinSpinResult(level);
            var respinResult   = RespinBonusEngine.CreateRespinResult(spinResult, level, requestContext, config);
            var bonus          = RespinBonusEngine.CreateRespinBonus(spinResult);

            bonus.UpdateBonus(respinResult);

            var respinBonusResult = RespinBonusEngine.CreateRespinBonusResult(bonus, respinResult);
            var xElement          = respinBonusResult.ToXElement();
            var responseXml       = new RespinBonusXml();

            using (var xmlReader = xElement.CreateReader())
            {
                responseXml.ReadXml(xmlReader);
            }

            Assert.IsNull(responseXml.GetSchema());
            Assert.AreEqual(respinBonusResult.Win, responseXml.TotalWin);
            Assert.AreEqual(0, responseXml.Counter);
            Assert.AreEqual(1, responseXml.NumberOfFreeSpin);
        }
        public void EngineShouldCreateRespinBonus(int level)
        {
            var spinResult = GenerateWithRespinSpinResult(level);

            Assert.DoesNotThrow(() => RespinBonusEngine.CreateRespinBonus(spinResult));
        }