Example #1
0
 public void ThenIShouldSeeStatusCodeSuccessfulAndResponseSchemaValidated(int p0)
 {
     Assert.DoesNotThrow(async() => await MemberApiProxy.BonusRedemptionsAsync());
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetRedemption(Guid.NewGuid()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetQualifiedBonuses(new QualifiedBonusRequest()
     {
         Amount = 10
     }));
     Assert.DoesNotThrow(async() => await MemberApiProxy.QualifiedFirstDepositBonuses(new QualifiedBonusRequest()
     {
         Amount = 10
     }));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetFirstDepositBonuseByCode(new FirstDepositApplicationRequest()));
     Assert.DoesNotThrow(async() =>
                         await MemberApiProxy.ValidateFirstOnlineDeposit(new FirstDepositApplicationRequest()
     {
         BonusCode     = TestDataGenerator.GetRandomString(4),
         DepositAmount = 50
     }));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetCompleteBonuses());
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetBonusesWithIncompleteWagering());
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetVisibleDepositQualifiedBonuses(new QualifiedBonusRequest()
     {
         Amount = 10
     }));
 }
Example #2
0
        public async Task ThenIShouldSeeStatusCodeCreatedAndResponseSchemaValidated(int p0)
        {
            //Act
            ScenarioContext.Current[ClaimedBonusRedemption] =
                await MemberApiProxy.ClaimRedemptionAsync(new ClaimRedemptionRequest());

            //From this point on we check if the returned by the POST uri is not empty
            ScenarioContext.Current[ClaimedBonusRedemption].Should().NotBeNull();

            var uriToClaimedRedemption = ((ClaimRedemptionResponse)
                                          (ScenarioContext.Current[ClaimedBonusRedemption]))
                                         .UriToClaimedRedemption;

            uriToClaimedRedemption.Should()
            .NotBeEmpty();

            //From this point on we check if the returned by the POST uri is accurate and working
            using (var client = new HttpClient())
            {
                AssignDefaultHeaderValues(client);

                CheckUpdatedEntityAvailability(client,
                                               uriToClaimedRedemption.Split('?')[0],
                                               uriToClaimedRedemption.Split('?')[1]);
            }
        }
Example #3
0
        public void ThenIShouldSeeStatusCodeIndicatingInternalServerError(int p0)
        {
            Assert.That(
                Assert.Throws <MemberApiProxyException>(async() => await MemberApiProxy.GetOnSiteMessagesAsync())
                .StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            Assert.That(
                Assert.Throws <MemberApiProxyException>(async() => await MemberApiProxy.GetBalancesSetAsync())
                .StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            Assert.That(
                Assert.Throws <MemberApiProxyException>(
                    () => MemberApiProxy.GetAvailableLanguages(Guid.NewGuid())).StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            Assert.That(
                Assert.Throws <MemberApiProxyException>(
                    async() => await MemberApiProxy.RegistrationFormDataAsync(new RegistrationFormDataRequest()
            {
                BrandId = Guid.NewGuid()
            })).StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            Assert.That(
                Assert.Throws <MemberApiProxyException>(
                    async() => await MemberApiProxy.ArePlayersIdDocumentsValid()).StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            ServiceLayerMockingHelper.VerifyLogginServiceWasCalledAfterInternalServerError(5);
        }
Example #4
0
        public void WhenITryToSendRequestToEndPointAndGetResponse()
        {
            var ipAddress = Get <string>(SecurityContextFields.IpAddress);
            var brandName = Get <string>(SecurityContextFields.BrandName);

            var request = new VerifyIpRequest
            {
                IpAddress = ipAddress,
                BrandName = brandName
            };

            try
            {
                var result = MemberApiProxy.VerifyIp(request);

                result.Should().NotBeNull();

                Set(SecurityContextFields.ErrorCode, HttpStatusCode.OK);
                Set(SecurityContextFields.Result, result);
            }
            catch (MemberApiValidationException e)
            {
                Set(SecurityContextFields.ErrorCode, e.StatusCode);

                var regoValidationError = e.ValidationErrors.FirstOrDefault();
                if (regoValidationError != null)
                {
                    Set(SecurityContextFields.ErrorMessage, regoValidationError.ErrorMessage);
                }
            }
        }
Example #5
0
        public void ThenAsAResponseIShouldSeeStatusCodeBadRequest(int p0)
        {
            Assert.Throws <MemberApiValidationException>(async() => await MemberApiProxy.ProfileAsync());
            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetOnSiteMessageAsync(new OnSiteMessageRequest()
            {
                OnSiteMessageId = Guid.NewGuid()
            }));
            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetWalletsAsync(Guid.NewGuid()));

            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetPlayerData(TestDataGenerator.GetRandomString()));

            //Test anonymous requests
            SetInvalidToken();

            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetSecurityQuestionAsync(Guid.NewGuid()));

            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetAcknowledgementDataAsync(Guid.NewGuid()));

            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetPlayerByResetPasswordToken(TestDataGenerator.GetRandomString()));
        }
        public MemberApiController()
        {
            var appSettings = new AppSettings();

            _brandId = appSettings.BrandId;

            var    cookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];
            string token  = null;

            if (cookie != null && !String.IsNullOrWhiteSpace(cookie.Value))
            {
                try
                {
                    var formsTicket = FormsAuthentication.Decrypt(cookie.Value);
                    if (formsTicket != null)
                    {
                        token = formsTicket.UserData;
                    }
                }
                catch (CryptographicException)
                {
                }
            }
            _memberApiProxy = new MemberApiProxy(appSettings.MemberApiUrl.ToString(), token);
        }
Example #7
0
        public void WhenITryToSendRequestToBonusControllerAPI(string p0)
        {
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.BonusRedemptionsAsync()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetQualifiedBonuses(new QualifiedBonusRequest())).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.QualifiedFirstDepositBonuses(new QualifiedBonusRequest())).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetFirstDepositBonuseByCode(new FirstDepositApplicationRequest())).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.ValidateFirstOnlineDeposit(new FirstDepositApplicationRequest())).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetCompleteBonuses()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetBonusesWithIncompleteWagering()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetVisibleDepositQualifiedBonuses(new QualifiedBonusRequest()
            {
                Amount = 10
            })).Exception.ErrorMessage);
        }
Example #8
0
 public void ThenIShouldSeeStatusCodeForAllOfTheCalls(int p0)
 {
     Assert.Throws <MemberApiValidationException>(async() =>
                                                  await MemberApiProxy.GameListAsync(new GamesRequest
     {
         PlayerUsername = TestDataGenerator.GetRandomString()
     }));
 }
Example #9
0
        public async Task WhenIQueryTheOnlineDeposit()
        {
            var orderId = Get <string>(OnlineDepositOrderIdKey);
            var request = new CheckOnlineDepositStatusRequest
            {
                TransactionNumber = orderId
            };
            var result = await MemberApiProxy.CheckOnlineDepositStatusAsync(request);

            Set(OnlineDepositQueryStatusResponseKey, result);
        }
Example #10
0
 public void ThenIShouldSeeStatusCodeSuccessfulForAllOfTheCalls(int p0)
 {
     Assert.DoesNotThrow(async() => await MemberApiProxy.GameListAsync(new GamesRequest
     {
         IsForMobile     = true,
         LobbyUrl        = TestDataGenerator.GetRandomString(),
         PlayerIpAddress = TestDataGenerator.GetRandomIpAddress(),
         PlayerUsername  = TestDataGenerator.GetRandomString(),
         UserAgent       = TestDataGenerator.GetRandomString()
     }));
 }
Example #11
0
        public async Task ThenOnlineDepositFormDataIsVisibleToMe()
        {
            var result = await MemberApiProxy.GetOnlineDepositFormDataAsync(BrandId);

            result.Should().NotBeNull();
            result.PaymentGatewaySettings.Any().Should().BeTrue();
            var settings = result.PaymentGatewaySettings.FirstOrDefault();

            settings.PaymentGatewayName.Should().NotBeNullOrEmpty();
            settings.Channel.Should().BeGreaterOrEqualTo(0);
        }
Example #12
0
        protected async Task LogInMemberApi(string username, string password)
        {
            var response = await MemberApiProxy.Login(new LoginRequest
            {
                BrandId        = BrandId,
                Username       = username,
                IPAddress      = "::1",
                Password       = password,
                RequestHeaders = new Dictionary <string, string>()
            });

            Token = response.AccessToken;
        }
Example #13
0
        public async Task WhenISubmitOnlineDepositRequest()
        {
            var result = await MemberApiProxy.OnlineDepositAsync(new OnlineDepositRequest
            {
                Amount      = 200,
                BrandId     = BrandId,
                CultureCode = "en-US",
                NotifyUrl   = "http://membersite/notifyurl",
                ReturnUrl   = "http://memebersite/returnurl"
            });

            Set(OnlineDepositResponseKey, result);
        }
Example #14
0
        public void ThenIShouldSeeStatusForNotAvailableService()
        {
            Assert.That(
                Assert.Throws <MemberApiProxyException>(async() => await MemberApiProxy.GetCompleteBonuses())
                .StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            Assert.That(
                Assert.Throws <MemberApiProxyException>(async() => await MemberApiProxy.GetBonusesWithIncompleteWagering())
                .StatusCode,
                Is.EqualTo(HttpStatusCode.InternalServerError));

            ServiceLayerMockingHelper.VerifyLogginServiceWasCalledAfterInternalServerError(2);
        }
Example #15
0
        public void ThenIShouldSeeStatusCodeBadRequest(int p0)
        {
            Assert.Throws <MemberApiValidationException>(async() => await MemberApiProxy.GetRedemption(Guid.NewGuid()));
            Assert.Throws <MemberApiValidationException>(
                async() => await MemberApiProxy.GetFirstDepositBonuseByCode(new FirstDepositApplicationRequest()
            {
                DepositAmount = 10,
                BonusCode     = Guid.NewGuid().ToString(),
                PlayerId      = Guid.NewGuid()
            }));

            Assert.Throws <MemberApiValidationException>(async() => await MemberApiProxy.GetVisibleDepositQualifiedBonuses(new QualifiedBonusRequest()
            {
                Amount = 100
            }));
        }
Example #16
0
 public void ThenTheReceivedStatusCodeMustBeSuccessfulAndResponseSchemaValidated(int p0)
 {
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetOfflineDepositFormDataAsync(Guid.NewGuid()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.PlayerLastDepositSummaryResponse());
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetOnlinePaymentSetting(Guid.NewGuid(), String.Empty));
     Assert.DoesNotThrow(async() => await MemberApiProxy.IsDepositorsFullNameValid(TestDataGenerator.GetRandomString()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetBankAccountsForOfflineDeposit());
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetPendingDeposits());
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetDeposits(1, null, null, null));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetOfflineDeposit(Guid.NewGuid()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetWithdrawalFormDataAsync(Guid.NewGuid()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetBanks());
     Assert.DoesNotThrow(async() => await MemberApiProxy.ValidatePlayerBankAccount(new PlayerBankAccountRequest()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetFundTransferFormDataAsync(Guid.NewGuid()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.ValidateOnlineDepositAmount(new ValidateOnlineDepositAmount()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetBankAccountForOfflineDeposit(Guid.NewGuid()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.CheckOnlineDepositStatusAsync(new CheckOnlineDepositStatusRequest()));
     Assert.DoesNotThrow(async() => await MemberApiProxy.GetOnlineDepositFormDataAsync(Guid.NewGuid()));
 }
Example #17
0
        public void Before()
        {
            SecurityHelper = Container.Resolve <SecurityTestHelper>();

            ValidationException =
                new RegoValidationException(
                    new ValidationResult(new[] { new ValidationFailure("brandName", "InvalidBrandCode") }));

            ErrorMessagesFromUnauthorizedCalls = new List <string>();

            _playerTestHelper = Container.Resolve <PlayerTestHelper>();

            TestStartup.Container = Container;

            MemberApiUrl = GetAvailableUrl(PortRangeStart, PortRangeEnd);

            _webServer = WebApp.Start <TestStartup>(MemberApiUrl);

            MemberApiProxy = new MemberApiProxy(MemberApiUrl);
        }
Example #18
0
        public async Task WhenIPayOnPaymentGateway()
        {
            var orderId     = Get <string>(OnlineDepositOrderIdKey);
            var fakeOrderId = DateTime.Now.ToString("yyyyMMddHHmmss");

            var request = new OnlineDepositPayNotifyRequest
            {
                OrderIdOfMerchant = orderId,
                OrderIdOfGateway  = "OID-Gateway" + fakeOrderId,
                OrderIdOfRouter   = "OID-Router" + fakeOrderId,
                PayMethod         = "XPAY",
                Language          = "zh-CN"
            };
            var sign = request.OrderIdOfMerchant + request.OrderIdOfRouter + request.OrderIdOfGateway + request.Language +
                       OnlineDepositKey;

            request.Signature = EncryptHelper.GetMD5HashInHexadecimalFormat(sign);
            var result = await MemberApiProxy.OnlineDepositPayNotifyAsync(request);

            Set(OnlineDepositNotifyResponseKey, result);
        }
Example #19
0
        public void WhenITryToSendGETRequestToPlayerControllerEndPoint()
        {
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.ProfileAsync()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.SecurityQuestionsAsync()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetOnSiteMessagesCountAsync()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetBalancesSetAsync()).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetWalletsAsync(Guid.NewGuid())).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetPlayerData(TestDataGenerator.GetRandomString())).Exception.ErrorMessage);

            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.ArePlayersIdDocumentsValid()).Exception.ErrorMessage);
        }
Example #20
0
        public void WhenITryToSendGETRequestWithoutHavingAValidTokenToPaymentControllerEndPoint()
        {
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetOfflineDepositFormDataAsync(Guid.NewGuid())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.PlayerLastDepositSummaryResponse()).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetOnlinePaymentSetting(Guid.NewGuid(), String.Empty)).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.IsDepositorsFullNameValid(TestDataGenerator.GetRandomString())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetBankAccountsForOfflineDeposit()).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetPendingDeposits()).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetDeposits(1, null, null, null)).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetOfflineDeposit(Guid.NewGuid())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetWithdrawalFormDataAsync(Guid.NewGuid())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetBanks()).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.ValidatePlayerBankAccount(new PlayerBankAccountRequest())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetFundTransferFormDataAsync(Guid.NewGuid())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.ValidateOnlineDepositAmount(new ValidateOnlineDepositAmount())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetBankAccountForOfflineDeposit(Guid.NewGuid())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.CheckOnlineDepositStatusAsync(new CheckOnlineDepositStatusRequest())).Exception.ErrorMessage);
            ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                       async() => await MemberApiProxy.GetOnlineDepositFormDataAsync(Guid.NewGuid())).Exception.ErrorMessage);

            //TODO: Add test cases for POST methods
        }
Example #21
0
        public void ThenIShouldSeeStatusCodeSuccessfulForEach(int p0, string p1)
        {
            Assert.DoesNotThrow(async() => await MemberApiProxy.ProfileAsync());
            Assert.DoesNotThrow(async() => await MemberApiProxy.SecurityQuestionsAsync());
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetBalancesSetAsync());
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetAcknowledgementDataAsync(Guid.NewGuid()));
            Assert.DoesNotThrow(
                async() =>
                await
                MemberApiProxy.GetOnSiteMessageAsync(new OnSiteMessageRequest()
            {
                OnSiteMessageId = Guid.NewGuid()
            }));
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetOnSiteMessagesAsync());
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetOnSiteMessagesCountAsync());

            Assert.DoesNotThrow(async() => await MemberApiProxy.GetWalletsAsync(Guid.NewGuid()));
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetPlayerData(TestDataGenerator.GetRandomString()));
            Assert.DoesNotThrow(async() => await MemberApiProxy.ArePlayersIdDocumentsValid());

            //Test anonymous requests
            SetInvalidToken();
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetSecurityQuestionAsync(Guid.NewGuid()));

            Assert.DoesNotThrow(
                async() =>
                await
                MemberApiProxy.RegistrationFormDataAsync(new RegistrationFormDataRequest()
            {
                BrandId = Guid.NewGuid()
            }));

            Assert.DoesNotThrow(() => MemberApiProxy.GetAvailableLanguages(Guid.NewGuid()));
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetAcknowledgementDataAsync(Guid.NewGuid()));
            Assert.DoesNotThrow(async() => await MemberApiProxy.GetPlayerByResetPasswordToken(Token));
        }
Example #22
0
        public override void BeforeEach()
        {
            _webServer = WebApp.Start <TestStartup>("http://*:5555");

            ServiceProxy = new MemberApiProxy("http://localhost:5555");
        }
Example #23
0
 public void WhenITryToSendGETRequestToGameControllerEndPoint()
 {
     ErrorMessagesFromUnauthorizedCalls.Add(Assert.Throws <MemberApiProxyException>(
                                                async() => await MemberApiProxy.GameListAsync(new GamesRequest())).Exception.ErrorMessage);
 }
Example #24
0
        public void WhenITryToSendPOSTRequestToPlayerControllerEndPoint()
        {
            ServiceLayerMockingHelper.MockPlayerCommandsForHttpStatus201(Container);

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromPasswordChanged] =
                                    await MemberApiProxy.ChangePasswordAsync(new ChangePasswordRequest()
            {
                OldPassword = LoggedInPlayerMetadata.Password,
                NewPassword = TestDataGenerator.GetRandomString(),
                Username    = LoggedInPlayerMetadata.Username
            }));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromPersonalInfoChanged] =
                                    await MemberApiProxy.ChangePersonalInfoAsync(new ChangePersonalInfoRequest()
            {
                PlayerId                 = PlayerId,
                FirstName                = TestDataGenerator.GetRandomString(),
                LastName                 = TestDataGenerator.GetRandomString(),
                Email                    = TestDataGenerator.GetRandomEmail(),
                CurrencyCode             = "CAD",
                DateOfBirth              = DateTime.UtcNow.AddYears(-30).ToString("yyyy/MM/dd"),
                Gender                   = "Male",
                Title                    = "Mr",
                CountryCode              = TestDataGenerator.GetRandomCountryCode(),
                MailingAddressCity       = TestDataGenerator.GetRandomString(),
                MailingAddressLine1      = TestDataGenerator.GetRandomString(),
                MailingAddressPostalCode = TestDataGenerator.GetRandomNumber(1000).ToString(),
                PhoneNumber              = TestDataGenerator.GetRandomPhoneNumber(),
                AccountAlertEmail        = false,
                AccountAlertSms          = true,
                MarketingAlertEmail      = true,
                MarketingAlertPhone      = false,
                MarketingAlertSms        = false
            }));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromContactInfoChanged] =
                                    await MemberApiProxy.ChangeContactInfoAsync(new ChangeContactInfoRequest()
            {
                PlayerId                 = PlayerId,
                MailingAddressCity       = TestDataGenerator.GetRandomString(),
                PhoneNumber              = TestDataGenerator.GetRandomPhoneNumber(false),
                CountryCode              = LoggedInPlayerMetadata.Country,
                MailingAddressLine1      = TestDataGenerator.GetRandomString(),
                MailingAddressPostalCode = TestDataGenerator.GetRandomNumber(1000).ToString()
            }));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromSelfExclusion] =
                                    await MemberApiProxy.SelfExclude(new SelfExclusionRequest()
            {
                Option   = (int)PlayerEnums.SelfExclusion._1Year,
                PlayerId = PlayerId
            }));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromTimeOut] =
                                    await MemberApiProxy.TimeOut(new TimeOutRequest()
            {
                PlayerId = PlayerId,
                Option   = (int)PlayerEnums.TimeOut.Month
            }));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromChangedSecurityQuestion] =
                                    await MemberApiProxy.ChangeSecurityQuestionAsync(new ChangeSecurityQuestionRequest()
            {
                Id                 = PlayerId.ToString(),
                SecurityAnswer     = TestDataGenerator.GetRandomString(),
                SecurityQuestionId = LoggedInPlayerMetadata.SecurityQuestion
            }));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromMobilePhoneVerification] =
                                    await MemberApiProxy.VerificationCodeAsync(new VerificationCodeRequest()));

            Assert.DoesNotThrow(async() =>
                                ScenarioContext.Current[ResponseFromMobilePhoneVerified] =
                                    await MemberApiProxy.VerifyMobileAsync(new VerifyMobileRequest()));
        }
Example #25
0
        public ElmahErrorLogger(IDictionary config)
        {
            var appSettings = new AppSettings();

            _serviceProxy = new MemberApiProxy(appSettings.MemberApiUrl.ToString(), Guid.NewGuid().ToString());
        }
Example #26
0
        public override void BeforeEach()
        {
            base.BeforeEach();

            FakeBrandRepository     = Container.Resolve <FakeBrandRepository>();
            FakePlayerRepository    = Container.Resolve <FakePlayerRepository>();
            FakePaymentRepository   = Container.Resolve <FakePaymentRepository>();
            FakeEventRepository     = Container.Resolve <FakeEventRepository>();
            FakeSecurityRepository  = Container.Resolve <FakeSecurityRepository>();
            FakeMessagingRepository = Container.Resolve <FakeMessagingRepository>();

            for (int i = 0; i < TestDataGenerator.CountryCodes.Length; i++)
            {
                FakeBrandRepository.Countries.Add(new Country {
                    Code = TestDataGenerator.CountryCodes[i]
                });
            }

            for (int i = 0; i < TestDataGenerator.CurrencyCodes.Length; i++)
            {
                FakeBrandRepository.Currencies.Add(new Currency {
                    Code = TestDataGenerator.CurrencyCodes[i]
                });
            }

            for (int i = 0; i < TestDataGenerator.CultureCodes.Length; i++)
            {
                FakeBrandRepository.Cultures.Add(new Culture {
                    Code = TestDataGenerator.CultureCodes[i]
                });
            }

            var brandId = new Guid("00000000-0000-0000-0000-000000000138");
            var brand   = new Core.Brand.Interface.Data.Brand {
                Id = brandId, Name = "138", Status = BrandStatus.Active, TimezoneId = "Pacific Standard Time"
            };

            for (int i = 0; i < TestDataGenerator.CurrencyCodes.Length; i++)
            {
                var currencyCode = TestDataGenerator.CurrencyCodes[i];

                brand.BrandCurrencies.Add(new BrandCurrency
                {
                    BrandId               = brand.Id,
                    Brand                 = brand,
                    CurrencyCode          = currencyCode,
                    Currency              = FakeBrandRepository.Currencies.Single(x => x.Code == currencyCode),
                    DefaultPaymentLevelId = currencyCode == "CAD"
                        ? new Guid("E1E600D4-0729-4D5C-B93E-085A94B55B33")
                        : new Guid("1ED97A2B-EBA2-4B68-A70C-18A7070908F9")
                });
            }
            for (int i = 0; i < TestDataGenerator.CountryCodes.Length; i++)
            {
                var countryCode = TestDataGenerator.CountryCodes[i];

                brand.BrandCountries.Add(new BrandCountry
                {
                    BrandId     = brand.Id,
                    Brand       = brand,
                    CountryCode = countryCode,
                    Country     = FakeBrandRepository.Countries.Single(x => x.Code == countryCode)
                });
            }
            for (int i = 0; i < TestDataGenerator.CultureCodes.Length; i++)
            {
                var cultureCode = TestDataGenerator.CultureCodes[i];

                brand.BrandCultures.Add(new BrandCulture
                {
                    BrandId     = brand.Id,
                    Brand       = brand,
                    CultureCode = cultureCode,
                    Culture     = FakeBrandRepository.Cultures.Single(x => x.Code == cultureCode)
                });
            }
            var walletTemplate = new WalletTemplate()
            {
                Brand       = brand,
                Id          = Guid.NewGuid(),
                IsMain      = true,
                Name        = "Main wallet",
                DateCreated = DateTimeOffset.UtcNow,
                CreatedBy   = Guid.NewGuid()
            };

            brand.WalletTemplates.Add(walletTemplate);
            brand.DefaultCulture  = brand.BrandCultures.First().Culture.Code;
            brand.DefaultCurrency = brand.BrandCurrencies.First().Currency.Code;
            var vipLevel = new Core.Brand.Interface.Data.VipLevel {
                Name = "Standard", BrandId = brandId
            };

            brand.DefaultVipLevelId = vipLevel.Id;
            brand.DefaultVipLevel   = vipLevel;

            FakeBrandRepository.WalletTemplates.Add(walletTemplate);
            var playerVipLevel = new VipLevel
            {
                Id      = Guid.NewGuid(),
                Name    = "Standard",
                BrandId = brandId
            };

            brand.DefaultVipLevelId = playerVipLevel.Id;

            FakeBrandRepository.Brands.Add(brand);
            var playerBrand = new Core.Common.Data.Player.Brand {
                Id = brand.Id, TimezoneId = brand.TimezoneId
            };

            FakePlayerRepository.Brands.Add(playerBrand);
            FakePlayerRepository.VipLevels.Add(playerVipLevel);

            FakeMessagingRepository.VipLevels.Add(new Core.Messaging.Data.VipLevel
            {
                Id   = playerVipLevel.Id,
                Name = playerVipLevel.Name
            });

            FakeMessagingRepository.SaveChanges();

            playerBrand.DefaultVipLevelId = playerVipLevel.Id;
            FakePlayerRepository.SaveChanges();

            foreach (var questionid in TestDataGenerator.SecurityQuestions)
            {
                FakePlayerRepository.SecurityQuestions.Add(new SecurityQuestion
                {
                    Id       = new Guid(questionid),
                    Question = TestDataGenerator.GetRandomString()
                });
            }

            Container.Resolve <FakeGameRepository>().Brands.Add(new Core.Game.Interface.Data.Brand
            {
                Id         = new Guid("00000000-0000-0000-0000-000000000138"),
                TimezoneId = TestDataGenerator.GetRandomTimeZone().Id
            });

            var bankAccountType = new BankAccountType
            {
                Id   = new Guid("00000000-0000-0000-0000-000000000100"),
                Name = "Main"
            };


            FakePaymentRepository.Brands.Add(new Core.Payment.Data.Brand
            {
                Id         = new Guid("00000000-0000-0000-0000-000000000138"),
                TimezoneId = "Pacific Standard Time"
            });

            FakePaymentRepository.BankAccountTypes.Add(bankAccountType);

            var bank = new Bank
            {
                Id          = Guid.NewGuid(),
                BankId      = "SE45",
                BankName    = "Bank of Canada",
                BrandId     = brandId,
                CountryCode = "Canada",
                Created     = DateTime.Now,
                CreatedBy   = "initializer"
            };

            FakePaymentRepository.Banks.Add(bank);

            var cadAccountId = new Guid("B6755CB9-8F9A-4EBA-87E0-1ED5493B7534");

            FakePaymentRepository.BankAccounts.Add(
                new BankAccount
            {
                Id            = cadAccountId,
                AccountId     = "BoC1",
                AccountName   = "John Doe",
                AccountNumber = "SE45 0583 9825 7466",
                AccountType   = bankAccountType,
                Bank          = bank,
                Branch        = "Main",
                Province      = "Vancouver",
                CurrencyCode  = "CAD",
                Created       = DateTime.Now,
                CreatedBy     = "Initializer",
                Status        = BankAccountStatus.Active,
                Updated       = DateTime.Now,
                UpdatedBy     = "Initializer"
            }
                );

            bankAccountType = new BankAccountType
            {
                Id   = new Guid("00000000-0000-0000-0000-000000000101"),
                Name = "VIP"
            };
            FakePaymentRepository.BankAccountTypes.Add(bankAccountType);

            bank = new Bank
            {
                Id          = Guid.NewGuid(),
                BankId      = "70AC",
                BankName    = "Hua Xia Bank",
                BrandId     = brandId,
                CountryCode = "China",
                Created     = DateTime.Now,
                CreatedBy   = "initializer"
            };
            FakePaymentRepository.Banks.Add(bank);

            var rmbAccountId = new Guid("13672261-70AC-46E3-9E62-9E2E3AB77663");

            FakePaymentRepository.BankAccounts.Add(
                new BankAccount
            {
                Id            = rmbAccountId,
                AccountId     = "HXB1",
                AccountName   = "Beijing",
                AccountNumber = "BA3912940494",
                //AccountType = "Main",
                AccountType  = bankAccountType,
                Bank         = bank,
                Branch       = "Main",
                Province     = "Beijing Municipality",
                CurrencyCode = "RMB",
                Created      = DateTime.Now,
                CreatedBy    = "Initializer",
                Status       = BankAccountStatus.Active,
                Updated      = DateTime.Now,
                UpdatedBy    = "Initializer"
            }
                );

            var paymentLevel = new PaymentLevel
            {
                Id                   = new Guid("E1E600D4-0729-4D5C-B93E-085A94B55B33"),
                BrandId              = brandId,
                CurrencyCode         = "CAD",
                Name                 = "CADLevel",
                Code                 = "CADLevel",
                EnableOfflineDeposit = true,
                DateCreated          = DateTimeOffset.Now,
                CreatedBy            = "Initializer"
            };

            paymentLevel.BankAccounts.Add(FakePaymentRepository.BankAccounts.Single(a => a.Id == cadAccountId));
            FakePaymentRepository.PaymentLevels.Add(paymentLevel);

            paymentLevel = new PaymentLevel
            {
                Id                   = new Guid("1ED97A2B-EBA2-4B68-A70C-18A7070908F9"),
                BrandId              = brandId,
                CurrencyCode         = "RMB",
                Name                 = "RMBLevel",
                Code                 = "RMBLevel",
                EnableOfflineDeposit = true,
                DateCreated          = DateTimeOffset.Now,
                CreatedBy            = "Initializer"
            };
            paymentLevel.BankAccounts.Add(FakePaymentRepository.BankAccounts.Single(a => a.Id == rmbAccountId));
            FakePaymentRepository.PaymentLevels.Add(paymentLevel);

            var licensee = new Licensee
            {
                Id = Guid.NewGuid(),
                AllowedBrandCount = 1,
                Status            = LicenseeStatus.Active
            };

            FakeBrandRepository.Licensees.Add(licensee);
            FakeBrandRepository.SaveChanges();

            foreach (var culture in FakeBrandRepository.Cultures)
            {
                FakeMessagingRepository.Languages.Add(new Language
                {
                    Code = culture.Code,
                    Name = culture.Name
                });
            }

            foreach (var thisBrand in FakeBrandRepository.Brands.Include(x => x.BrandCultures.Select(y => y.Culture)))
            {
                FakeMessagingRepository.Brands.Add(new Core.Messaging.Data.Brand
                {
                    Id        = thisBrand.Id,
                    Name      = thisBrand.Name,
                    SmsNumber = TestDataGenerator.GetRandomPhoneNumber(),
                    Email     = TestDataGenerator.GetRandomEmail(),
                    Languages = thisBrand.BrandCultures.Select(x => new Language
                    {
                        Code = x.Culture.Code,
                        Name = x.Culture.Name
                    }).ToList()
                });
            }

            foreach (var thisPlayer in FakePlayerRepository.Players)
            {
                FakeMessagingRepository.Players.Add(new Core.Messaging.Data.Player
                {
                    Id        = thisPlayer.Id,
                    Username  = thisPlayer.Username,
                    FirstName = thisPlayer.FirstName,
                    LastName  = thisPlayer.LastName,
                    Email     = thisPlayer.Email,
                    Language  = FakeMessagingRepository.Languages.Single(x => x.Code == thisPlayer.CultureCode),
                    Brand     = FakeMessagingRepository.Brands.Single(x => x.Id == thisPlayer.BrandId)
                });
            }

            foreach (var thisBrand in FakeMessagingRepository.Brands.Include(x => x.Languages))
            {
                foreach (var thisLanguage in thisBrand.Languages)
                {
                    foreach (var messageType in (MessageType[])Enum.GetValues(typeof(MessageType)))
                    {
                        FakeMessagingRepository.MessageTemplates.Add(new MessageTemplate
                        {
                            BrandId               = thisBrand.Id,
                            LanguageCode          = thisLanguage.Code,
                            MessageType           = messageType,
                            MessageDeliveryMethod = MessageDeliveryMethod.Email,
                            TemplateName          = TestDataGenerator.GetRandomString(),
                            MessageContent        = string.Format("Fake email message Template. {0}.",
                                                                  Enum.GetName(typeof(MessageType), messageType)),
                            Subject     = TestDataGenerator.GetRandomString(),
                            Status      = Status.Active,
                            CreatedBy   = "System",
                            Created     = DateTimeOffset.UtcNow,
                            ActivatedBy = "System",
                            Activated   = DateTimeOffset.UtcNow
                        });

                        FakeMessagingRepository.MessageTemplates.Add(new MessageTemplate
                        {
                            BrandId               = thisBrand.Id,
                            LanguageCode          = thisLanguage.Code,
                            MessageType           = messageType,
                            MessageDeliveryMethod = MessageDeliveryMethod.Sms,
                            TemplateName          = TestDataGenerator.GetRandomString(),
                            MessageContent        = string.Format("Fake SMS message Template. {0}.",
                                                                  Enum.GetName(typeof(MessageType), messageType)),
                            Status      = Status.Active,
                            CreatedBy   = "System",
                            Created     = DateTimeOffset.UtcNow,
                            ActivatedBy = "System",
                            Activated   = DateTimeOffset.UtcNow
                        });
                    }
                }
            }

            FakeMessagingRepository.SaveChanges();

            var securityHelper = Container.Resolve <SecurityTestHelper>();

            securityHelper.PopulatePermissions();

            var licenseeIds = new[] { licensee.Id };
            var brandIds    = new[] { brand.Id };

            const string superAdminUsername = "******";

            var adminId = RoleIds.SuperAdminId;
            var role    = new Role
            {
                Id          = adminId,
                Code        = "SuperAdmin",
                Name        = "SuperAdmin",
                CreatedDate = DateTime.UtcNow
            };

            role.SetLicensees(licenseeIds);

            var user = new Core.Security.Data.Users.Admin
            {
                Id          = adminId,
                Username    = superAdminUsername,
                FirstName   = superAdminUsername,
                LastName    = superAdminUsername,
                IsActive    = true,
                Description = superAdminUsername,
                Role        = role
            };

            user.SetLicensees(licenseeIds);

            foreach (var licenseeId in licenseeIds)
            {
                user.LicenseeFilterSelections.Add(new LicenseeFilterSelection
                {
                    AdminId    = user.Id,
                    LicenseeId = licenseeId,
                    Admin      = user
                });
            }

            user.SetAllowedBrands(brandIds);

            foreach (var item in brandIds)
            {
                user.BrandFilterSelections.Add(new BrandFilterSelection
                {
                    AdminId = user.Id,
                    BrandId = item,
                    Admin   = user
                });
            }

            FakeSecurityRepository.Admins.AddOrUpdate(user);
            var authCommands = Container.Resolve <IAuthCommands>();

            authCommands.CreateRole(new CreateRole
            {
                RoleId      = adminId,
                Permissions = Container.Resolve <IAuthQueries>().GetPermissions().Select(p => p.Id).ToList()
            });
            authCommands.CreateActor(new CreateActor
            {
                ActorId  = adminId,
                Username = superAdminUsername,
                Password = superAdminUsername
            });
            authCommands.AssignRoleToActor(new AssignRole
            {
                ActorId = adminId,
                RoleId  = adminId
            });

            FakeSecurityRepository.SaveChanges();

            securityHelper.SignInAdmin(user);

            var testServerUri = ConfigurationManager.AppSettings["TestServerUri"];

            TestStartup.Container = Container;
            _webServer            = WebApp.Start <TestStartup>(testServerUri);

            PlayerWebservice = new MemberApiProxy(testServerUri);
        }
Example #27
0
        protected void SetInvalidToken()
        {
            Token = TestDataGenerator.GetRandomString(300);

            MemberApiProxy = new MemberApiProxy(MemberApiUrl, Token);
        }