private VirtualNetworkLink CreateVirtualNetworkLink(
string resourceGroupName,
string privateZoneName,
bool registrationEnabled = false,
IDictionary <string, string> tags = null)
{
var virtualNetworkId = this.CreateVirtualNetwork(resourceGroupName).Id;
var virtualNetworkLinkName = TestDataGenerator.GenerateVirtualNetworkLinkName();
return(this.PrivateDnsManagementClient.VirtualNetworkLinks.CreateOrUpdate(
resourceGroupName: resourceGroupName,
privateZoneName: privateZoneName,
virtualNetworkLinkName: virtualNetworkLinkName,
parameters: TestDataGenerator.GenerateVirtualNetworkLink(
location: Constants.PrivateDnsZonesVirtualNetworkLinksLocation,
virtualNetworkId: virtualNetworkId,
registrationEnabled: registrationEnabled,
tags: tags)));
}
public void CreateNewModelSaveCancel()
{
TestDataGenerator.GenerateBox(MainWindow);
MainWindow.Ribbon.ClickFileMenuItem("NewModel");
// Save model?
var taskDlg = new TaskDialogAdaptor(MainWindow);
Assert.That(taskDlg.Title, Is.EqualTo("Unsaved Changes"));
taskDlg.ClickButton(TaskDialogAdaptor.Button.Yes);
var fileDlg = new FileDialogAdaptor(MainWindow);
Assert.That(fileDlg.Title, Is.EqualTo("Saving Model..."));
fileDlg.ClickButton(FileDialogAdaptor.Button.Cancel);
// Check that button box is still there
Assert.AreEqual(1, MainWindow.Document.GetBodyItems().Count());
}
public void ThenVipLevelIsSuccessfullyChanged()
{
ScenarioContext.Current.Should().ContainKey("playerId");
ScenarioContext.Current.Should().ContainKey("vipLevelId");
var playerId = ScenarioContext.Current.Get <Guid>("playerId");
var vipLevelId = ScenarioContext.Current.Get <Guid>("vipLevelId");
var data = new ChangeVipLevelData
{
NewVipLevel = vipLevelId,
PlayerId = playerId,
Remarks = TestDataGenerator.GetRandomString()
};
var result = AdminApiProxy.ChangeVipLevelInPlayerManager(data);
result.Should().NotBeNull();
result.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.OK);
}
public void Can_delete_backend_ip_regulation()
{
var form = _backendIpRegulationsPage.OpenNewBackendIpRegulationForm();
var data = new BackendIpRegulationData
{
IpAddress = TestDataGenerator.GetRandomIpAddress(),
AdvancedSettings = false,
Description = TestDataGenerator.GetRandomStringWithSpecialSymbols(10)
};
var submittedBackendIpRegulationForm = form.Submit(data);
Assert.AreEqual("IP Regulation has been successfully created", submittedBackendIpRegulationForm.ConfirmationMessage);
submittedBackendIpRegulationForm.Close();
_backendIpRegulationsPage.DeleteIpRegulation(data.IpAddress);
Assert.True(_backendIpRegulationsPage.IsIpRegulationExists(data.IpAddress));
}
public void TryGetDeviceInfosTest()
{
var ldbpp = DeleteAndInitTestDB2();
var deviceId1 = TestDataGenerator.GetDeviceId(0);
var deviceId2 = TestDataGenerator.GetDeviceId(1);
var deviceInfo1 = TestDataGenerator.GetDeviceInfo(deviceId1.User, 0);
deviceInfo1.FcmToken = "fcmtoken1";
var deviceInfo2 = TestDataGenerator.GetDeviceInfo(deviceId2.User, 1);
deviceInfo1.FcmToken = "fcmtoken2";
var deviceInfo3 = TestDataGenerator.GetDeviceInfo(deviceId2.User, 2);
deviceInfo1.FcmToken = "fcmtoken3";
ldbpp.AddOrUpdateDeviceInfos(deviceId1, deviceInfo1);
ldbpp.AddOrUpdateDeviceInfos(deviceId2, deviceInfo2);
ldbpp.AddOrUpdateDeviceInfos(deviceId2, deviceInfo3);
Assert.Equal(2, ldbpp.DeviceIdDeviceInfoLink.FindAll().Count());
//deviceLink1
var deviceLinks1 = ldbpp.DeviceIdDeviceInfoLink.Find(x => x.DeviceId.FullId == deviceId1.FullId);
Assert.Single(deviceLinks1);
var deviceLink1 = deviceLinks1.Single();
MyAsserts.Equal(deviceId1, deviceLink1.DeviceId);
MyAsserts.Equal(deviceInfo1, deviceLink1.DeviceInfo);
//deviceLink2
var deviceLinks2 = ldbpp.DeviceIdDeviceInfoLink.Find(x => x.DeviceId.FullId == deviceId2.FullId);
Assert.Single(deviceLinks2);
var deviceLink2 = deviceLinks2.Single();
MyAsserts.Equal(deviceId2, deviceLink2.DeviceId);
MyAsserts.Equal(deviceInfo3, deviceLink2.DeviceInfo);
}
public void Copy_permissions_from_role_option_works()
{
// create a source role to copy permissions from
var sourceRoleData = TestDataGenerator.CreateValidRoleData(code: null, name: null, licensee: DefaultLicensee);
_roleManagerPage = _dashboardPage.Menu.ClickRoleManagerMenuItem();
var sourceRoleForm = _roleManagerPage.OpenNewRoleForm();
sourceRoleForm.SelectPermissions(new []
{
NewRoleForm.RoleManagerView, NewRoleForm.RoleManagerCreate
});
var submittedSorceRole = sourceRoleForm.FillInRequiredFieldsAndSubmit(sourceRoleData);
// create another role to use the copied permissions
var roleData = TestDataGenerator.CreateValidRoleData(code: null, name: null, licensee: DefaultLicensee);
submittedSorceRole.CloseTab("View Role");
var newRoleForm = _roleManagerPage.OpenNewRoleForm();
var submittedRoleForm = newRoleForm.FillInRequiredFields(roleData);
newRoleForm.CopyPermissionsFromAnotherRole(sourceRoleData.RoleName);
newRoleForm.Submit();
// create a user based on the role
var userData = TestDataGenerator.CreateValidAdminUserRegistrationData(
roleData.RoleName, status: "Active", licensee: roleData.Licensee, brand: DefaultBrand, currency: "CAD");
var adminManagerPage = submittedRoleForm.Menu.ClickAdminManagerMenuItem();
var newUserForm = adminManagerPage.OpenNewUserForm();
var submittedUserForm = newUserForm.Submit(userData);
Assert.AreEqual("User has been successfully created", submittedUserForm.ConfirmationMessage);
Assert.AreEqual(roleData.RoleName, submittedUserForm.UserRole);
// login as the user and check that the user can open Role Manager page
_dashboardPage = _driver.LoginToAdminWebsiteAs(userData.UserName, userData.Password);
_roleManagerPage = _dashboardPage.Menu.ClickRoleManagerMenuItem();
var openedForm = _roleManagerPage.OpenNewRoleForm();
Assert.AreEqual("New Role", openedForm.TabName);
}
public void Execute_MixedBatch_Test()
{
// Generate test user
const int idx = 20;
var testUser = new InsertUser
{
Id = Guid.NewGuid(),
Name = string.Format("Name {0}", idx),
Age = idx,
CreatedDate = TestDataGenerator.GetDateTimeInPast(idx),
IsActive = idx % 2 == 0,
LastLoginDate = TestDataGenerator.GetNullableDateTimeInPast(idx),
LoginHistory = TestDataGenerator.GetList(idx, TestDataGenerator.GetDateTimeInPast),
LuckyNumbers = TestDataGenerator.GetSet(idx, i => i),
FavoriteColor = TestDataGenerator.GetEnumValue <RainbowColor>(idx),
TypeOfUser = TestDataGenerator.GetEnumValue <UserType?>(idx),
PreferredContact = TestDataGenerator.GetEnumValue <ContactMethod>(idx),
HairColor = TestDataGenerator.GetEnumValue <HairColor>(idx)
};
// Get id of existing user for deleting and updating
Guid deleteId = Guid.NewGuid();
Guid updateId = Guid.NewGuid();
// Create batch of mixed statements and execute
var mapper = GetMapper(() => TestHelper.DelayedTask(new RowSet()));
ICqlBatch batch = mapper.CreateBatch();
batch.Insert(testUser);
batch.Delete <InsertUser>("WHERE userid = ?", deleteId);
batch.Update <InsertUser>("SET name = ? WHERE userid = ?", "SomeNewName", updateId);
var queries = batch.Statements.Select(cql => cql.Statement).ToArray();
Assert.AreEqual(3, queries.Length);
Assert.AreEqual("INSERT INTO users (userid, Name, Age, CreatedDate, IsActive, " +
"LastLoginDate, LoginHistory, LuckyNumbers, ChildrenAges, " +
"FavoriteColor, TypeOfUser, preferredcontactmethod, HairColor) VALUES " +
"(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", queries[0]);
Assert.AreEqual("DELETE FROM users WHERE userid = ?", queries[1]);
Assert.AreEqual("UPDATE users SET name = ? WHERE userid = ?", queries[2]);
mapper.Execute(batch);
}
public void Can_edit_brand_ip_regulation()
{
var form = _brandIpRegulationManagerPage.OpenNewBrandIpRegulationForm();
var data = new BrandIpRegulationData
{
Licensee = "Flycow",
Brand = "138",
IpAddress = TestDataGenerator.GetRandomIpAddress(),
AdvancedSettings = false,
Description = "test ip regulation",
Restriction = "Block",
BlockingType = "Redirection",
RedirectUrl = "http://test.com"
};
var submittedForm = form.Submit(data);
Assert.AreEqual("IP Regulation has been successfully created", submittedForm.ConfirmationMessage);
Assert.AreEqual(data.IpAddress, submittedForm.IpAddress);
submittedForm.Close();
var editForm = _brandIpRegulationManagerPage.OpenEditBrandIpRegulationForm(data.IpAddress);
var editData = new BrandIpRegulationData
{
Licensee = "Flycow",
Brand = "138",
IpAddress = TestDataGenerator.GetRandomIpAddress(),
AdvancedSettings = false,
Description = "test edit ip regulation",
Restriction = "Block",
BlockingType = "Redirection",
RedirectUrl = "http://test.com"
};
editForm.ClearFieldsOnForm();
var submittedEditForm = editForm.Submit(editData);
Assert.AreEqual("IP Regulation has been successfully updated", submittedEditForm.ConfirmationMessage);
Assert.AreEqual(editData.IpAddress, submittedEditForm.IpAddress);
}
public void GivenCalculationsWithoutOutput_WhenChangingNormativeProbabilityType_ThenActionPerformedAndContributionNotified()
{
// Given
DialogBoxHandler = (name, wnd) =>
{
var tester = new MessageBoxTester(wnd);
tester.ClickOk();
};
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
var calculations = new List <ICalculation>();
calculations.AddRange(assessmentSection.Piping.Calculations
.OfType <SemiProbabilisticPipingCalculationScenario>()
.Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput));
calculations.AddRange(assessmentSection.MacroStabilityInwards.Calculations
.OfType <MacroStabilityInwardsCalculationScenario>()
.Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput));
calculations.ForEachElementDo(c => c.ClearOutput());
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver()).Repeat.Once();
mocks.ReplayAll();
assessmentSection.FailureMechanismContribution.Attach(observer);
var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
// When
var actionPerformed = false;
void Call() => handler.ChangeNormativeProbabilityType(() => actionPerformed = true);
// Then
TestHelper.AssertLogMessagesCount(Call, 0);
Assert.IsTrue(actionPerformed);
mocks.VerifyAll();
}
public void ApplyFiltersShouldHandleComparisonsDifferentlyForStrings()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var caseSensitiveFilters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "testSix",
PropertyName = nameof(TestModel.Name),
Operator = FilterOperation.GreaterThan,
CaseSensitive = true
}
}
};
List <TestModel> result = currentSet.ApplyFilters(caseSensitiveFilters).ToList();
Assert.NotEmpty(result);
Assert.Equal(currentSet.ElementAtOrDefault(1), result[0]);
Assert.Equal(currentSet.ElementAtOrDefault(2), result[1]);
var caseInsensitiveFilters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = "testSix",
PropertyName = nameof(TestModel.Name),
Operator = FilterOperation.GreaterThan,
CaseSensitive = false
}
}
};
result = currentSet.ApplyFilters(caseInsensitiveFilters).ToList();
Assert.NotEmpty(result);
Assert.Equal(currentSet.ElementAtOrDefault(1), result[0]);
Assert.Equal(currentSet.ElementAtOrDefault(2), result[1]);
}
public void Cannot_manage_language_without_permission()
{
//create a user
var roleData = TestDataGenerator.CreateValidRoleData(code: null, name: null, licensee: DefaultLicensee);
var userData = TestDataGenerator.CreateValidAdminUserRegistrationData(
roleData.RoleName, status: "Active", licensee: roleData.Licensee, brand: DefaultBrand, currency: "ALL");
_driver.CreateUser(roleData, userData, new[] { NewRoleForm.LanguageManagerView });
Thread.Sleep(5000); //wait for new User event proceeds.
//log in as the user
_dashboardPage = _driver.LoginToAdminWebsiteAs(userData.UserName, userData.Password);
var languageManagerPage = _dashboardPage.Menu.ClickLanguageManagerMenuItem();
foreach (var btnName in new[] { "new", "edit", "activate", "deactivate" })
{
var button = languageManagerPage.GetButton(btnName);
Assert.That(!button.Displayed);
}
}
public void Can_create_user_with_permission()
{
// create a user
var roleData = TestDataGenerator.CreateValidRoleData(code: null, name: null, licensee: DefaultLicensee);
var userData = TestDataGenerator.CreateValidAdminUserRegistrationData(
roleData.RoleName, status: "Active", licensee: DefaultLicensee, brand: DefaultBrand, currency: "ALL");
_driver.CreateUser(roleData, userData, new[]
{
NewRoleForm.AdminManagerView, NewRoleForm.AdminManagerCreate
});
Thread.Sleep(5000); //wait for new User event proceeds.
//log in as the user
_dashboardPage = _driver.LoginToAdminWebsiteAs(userData.UserName, userData.Password);
var adminManagerPage = _dashboardPage.Menu.ClickAdminManagerMenuItem();
var newForm = adminManagerPage.OpenNewUserForm();
Assert.AreEqual("New User", newForm.TabName);
}
public void Can_process_verify_deposit()
{
// Arrange
var depositAmount = TestDataGenerator.GetRandomDepositAmount();
var deposit = PaymentTestHelper.CreateOfflineDeposit(_player.Id, depositAmount);
PaymentTestHelper.ConfirmOfflineDeposit(deposit);
// Act
PaymentTestHelper.VerifyOfflineDeposit(deposit, true);
// Assert
Assert.AreEqual(1, _reportRepository.DepositRecords.Count());
var record = _reportRepository.DepositRecords.Single();
Assert.AreEqual(deposit.Id, record.DepositId);
Assert.Less(DateTimeOffset.Now.AddDays(-2), record.Verified);
Assert.AreEqual(_actorInfoProvider.Actor.UserName, record.VerifiedBy);
Assert.AreEqual(OfflineDepositStatus.Verified.ToString(), record.Status);
}
public void Cannot_access_admin_website_with_ip_address_specified_in_ipv6_format()
{
// *** Arrange ***
var ipAddressv6 = TestDataGenerator.GetRandomIpAddress(IpVersion.Ipv6);
var adminIpRegulationData = new AddBackendIpRegulationData
{
IpAddress = ipAddressv6
};
_backendService.CreateIpRegulation(adminIpRegulationData);
var ipAddressNotInWhiteList = TestDataGenerator.GetRandomIpAddress(IpVersion.Ipv6);
// *** Act ***
var isIpAddressBlocked = _backendService.VerifyIpAddress(ipAddressNotInWhiteList);
// *** Assert ***
Assert.True(isIpAddressBlocked);
}
public CardServiceTest()
{
var cardNumberGenerator = new CardNumberGeneratorMockFactory().MockObject();
var cardCheckerMock = new CardCheckerMockFactory().Mock();
_currencyConverterMock = new Mock <ICurrencyConverter>();
_currencyConverterMock.Setup(
c => c.GetConvertedSum(
It.IsAny <decimal>(),
It.IsAny <Currency>(),
It.IsAny <Currency>()))
.Returns(10M);
_cardService = new CardService(
cardCheckerMock.Object,
_currencyConverterMock.Object,
new Mock <ICardRepository>().Object);
_testDataGenerator = new TestDataGenerator(_cardService, cardNumberGenerator);
}
public TestDataGeneratorTypeExtensionSpeck()
{
Specify(x =>
TestDataGenerator.Create <ClassWithVeryPropertyToArgConversion> (MaxRecursionDepth, null))
.Case("should fill class according to custom parameter to property conversion", _ => _
.Given(ValueProviderCustomConversion())
.It("should fill name through argument", x => x.Result.Name.Should().Be("NameThroughValue")));
Specify(x =>
TestDataGenerator.Create <ClassWithAttribute> (MaxRecursionDepth, null))
.Case("should fill class according to extended attributes", _ => _
.Given(ValueProviderWithExtendedAttributes(new ClassWithAttribute.CoolIntAttribute(10)))
.It("should fill attributed int through extended attributes", x => x.Result.AttributedInt.Should().Be(21)));
Specify(x =>
TestDataGenerator.Create <ImmutableIce> (MaxRecursionDepth, null))
.Case("should fill immutable class according to extended attributes", _ => _
.Given(ValueProviderForImmutableClassWithExtendedAttributes(new ClassWithAttribute.CoolIntAttribute(100)))
.It("should fill temperature through extended attributes", x => x.Result.Temperature.Should().Be(100)));
}
public void Unknown_brandId_isnt_valid()
{
var model = new CreateUpdateTemplate
{
Id = Guid.Empty,
Info = new CreateUpdateTemplateInfo
{
Name = TestDataGenerator.GetRandomString(),
BrandId = Guid.NewGuid(),
WalletTemplateId = Guid.NewGuid(),
TemplateType = BonusType.FirstDeposit,
Mode = IssuanceMode.Automatic
}
};
var validationResult = BonusQueries.GetValidationResult(model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.TemplateBrandDoesNotExist, message);
}
private Card GetCard_ValidData()
{
// Arrange
var fakeCard = _testDataGenerator.GenerateFakeCard(
new CardPostDto
{
Name = "my card",
Currency = (int)Currency.RUR,
Type = (int)CardType.MAESTRO
});
var fakeCardGetDto = TestDataGenerator.GenerateFakeCardGetDto(fakeCard);
_cardCheckerMock.Setup(r => r.CheckCardEmitter(fakeCard.CardNumber)).Returns(true);
_cardRepositoryMock.Setup(r => r.GetWithTransactions(_user, fakeCard.CardNumber, true)).Returns(fakeCard);
_dtoFactoryMock.Setup(d => d.Map(fakeCard, It.IsAny <Func <CardGetDto, bool> >()))
.Returns(fakeCardGetDto);
return(fakeCard);
}
public Player CreatePlayer(bool isActive = true, Guid?brandId = null)
{
var playerRegData = TestDataGenerator.CreateRandomRegistrationRequestData();
var registrationData = Mapper.DynamicMap <RegistrationData>(playerRegData);
brandId = brandId ?? _brandRepository.Brands.First().Id;
var brand = _brandQueries.GetBrandOrNull(brandId.Value);
registrationData.BrandId = brand.Id.ToString();
registrationData.CountryCode = brand.BrandCountries.First().Country.Code;
registrationData.CurrencyCode = brand.BrandCurrencies.First().CurrencyCode;
registrationData.CultureCode = brand.BrandCultures.First().CultureCode;
registrationData.IsInactive = !isActive;
registrationData.AccountAlertEmail = true;
registrationData.AccountAlertSms = true;
var playerId = _playerCommands.Register(registrationData);
return(_playerQueries.GetPlayer(playerId));
}
public void ExportTest()
{
#region Adding To DB
var dbRepository = new LiteDbKeySwitchRepository(new MemoryStream());
var entity = TestDataGenerator.CreateKeySwitch();
dbRepository.Save(entity);
#endregion
var inputData = new SearchingRequest(entity.DeveloperName.Value, entity.ProductName.Value);
var interactor = new SearchingInteractor(
dbRepository,
new KeySwitchListListToJsonModelList {
Formatted = true
},
new ISearchingPresenter.Console()
);
var response = interactor.Execute(inputData);
Console.WriteLine(response);
}
public void PutRecordSet_IfMatchFailure_ExpectError()
{
var resourceGroupName = this.CreateResourceGroup().Name;
var privateZoneName = this.CreatePrivateZone(resourceGroupName).Name;
var recordType = RecordType.A;
var recordSetName = "recordName";
var parameters = TestDataGenerator.GenerateRecordSetWithARecords();
var createdRecordSet = this.PrivateDnsManagementClient.RecordSets.CreateOrUpdate(resourceGroupName, privateZoneName, recordType, recordSetName, parameters);
Action updatedRecordSetAction = () => this.PrivateDnsManagementClient.RecordSets.CreateOrUpdate(
resourceGroupName: resourceGroupName,
privateZoneName: privateZoneName,
recordType: recordType,
relativeRecordSetName: recordSetName,
ifMatch: Guid.NewGuid().ToString(),
parameters: parameters);
updatedRecordSetAction.Should().Throw <CloudException>().Which.Response.StatusCode.Should().Be(HttpStatusCode.PreconditionFailed);
}
public void Can_create_and_view_bonus_with_MarketingOfficer_permissions()
{
// create a user with MarketingOfficer permissions
var bonusName = "Bonus" + TestDataGenerator.GetRandomString(5);
var bonusCode = TestDataGenerator.GetRandomString(5);
var userData = TestDataGenerator.CreateValidAdminUserRegistrationData(
role: "MarketingOfficer", status: "Active", licensee: DefaultLicensee, brand: DefaultBrand, currency: "EUR");
_driver.CreateUserBasedOnPredefinedRole(userData);
Thread.Sleep(5000); //wait for new User event proceeds.
// log in as the user and view bonus
_dashboardPage = _driver.LoginToAdminWebsiteAs(userData.UserName, userData.Password);
var bonusManagerPage = _dashboardPage.Menu.ClickBonusMenuItem();
var newBonusForm = bonusManagerPage.OpenNewBonusForm();
var submittedForm = newBonusForm.Submit(bonusName, bonusCode, _bonusTemplateName, numberOfdaysToClaimBonus: 20);
Assert.AreEqual("Bonus has been successfully created.", submittedForm.ConfirmationMessageAfterBonusSaving);
Assert.AreEqual("View bonus", submittedForm.TabName);
}
public void SettingsItems_saves_and_restores_with_multiple_settings()
{
string key1 = TestDataGenerator.GetRandomString();
string value1 = TestDataGenerator.GetRandomString();
string key2 = TestDataGenerator.GetRandomString();
string value2 = TestDataGenerator.GetRandomString();
string key3 = TestDataGenerator.GetRandomString();
string value3 = TestDataGenerator.GetRandomString();
_settingsCommands.Save(key1, value1);
_settingsCommands.Save(key2, value2);
_settingsCommands.Save(key3, value3);
var restoredValue1 = _settingsQueries.Get(key1);
var restoredValue2 = _settingsQueries.Get(key2);
var restoredValue3 = _settingsQueries.Get(key3);
Assert.AreEqual(value1, restoredValue1);
Assert.AreEqual(value2, restoredValue2);
Assert.AreEqual(value3, restoredValue3);
}
public void Can_fail_missing_required_fields_sms()
{
var data = new AddMessageTemplate
{
BrandId = Brand.Id,
MessageType = TestDataGenerator.GetRandomMessageType(),
MessageDeliveryMethod = MessageDeliveryMethod.Sms,
};
var result = MessageTemplateQueries.GetValidationResult(data);
Assert.That(result.Errors.Count, Is.EqualTo(3));
Assert.That(result.Errors.All(x => x.ErrorMessage ==
Enum.GetName(typeof(MessagingValidationError), MessagingValidationError.Required)));
Assert.That(result.Errors.SingleOrDefault(x => x.PropertyName == "LanguageCode"), Is.Not.Null);
Assert.That(result.Errors.SingleOrDefault(x => x.PropertyName == "TemplateName"), Is.Not.Null);
Assert.That(result.Errors.SingleOrDefault(x => x.PropertyName == "MessageContent"), Is.Not.Null);
}
public async Task Fund_out_is_idempotent()
{
var transactionId = Guid.NewGuid().ToString();
var amount = TestDataGenerator.GetRandomDepositAmount();
var player = PlayerTestHelper.CreatePlayer();
WaitForPlayerRegistered(player.Id);
PaymentTestHelper.MakeDeposit(player.Id, amount * 2, waitForProcessing: true);
var balanceFromAnswer1 = await _brandOperations.FundOutAsync(player.Id, amount, player.CultureCode, transactionId);
var balanceFromAnswer2 = await _brandOperations.FundOutAsync(player.Id, amount, player.CultureCode, transactionId);
var balanceFromRequest = await _brandOperations.GetPlayerBalanceAsync(player.Id, player.CurrencyCode);
Assert.AreEqual(amount, balanceFromAnswer1);
Assert.AreEqual(amount, balanceFromAnswer2);
Assert.AreEqual(amount, balanceFromRequest);
}
public void GivenValidDialog_WhenGetMergeDataCalledAndImportPressed_ThenReturnsSelectedData()
{
// Given
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsAndSpecificFailureMechanisms();
DialogBoxHandler = (formName, wnd) =>
{
using (new FormTester(formName))
{
var button = new ButtonTester("importButton", formName);
button.Click();
}
};
using (var dialogParent = new Form())
using (var dialog = new AssessmentSectionMergeDataProviderDialog(dialogParent))
{
// When
AssessmentSectionMergeData result = dialog.GetMergeData(assessmentSection);
// Then
Assert.AreSame(assessmentSection, result.AssessmentSection);
Assert.IsFalse(result.MergePiping);
Assert.IsFalse(result.MergeGrassCoverErosionInwards);
Assert.IsFalse(result.MergeMacroStabilityInwards);
Assert.IsFalse(result.MergeMicrostability);
Assert.IsFalse(result.MergeStabilityStoneCover);
Assert.IsFalse(result.MergeWaveImpactAsphaltCover);
Assert.IsFalse(result.MergeWaterPressureAsphaltCover);
Assert.IsFalse(result.MergeGrassCoverErosionOutwards);
Assert.IsFalse(result.MergeGrassCoverSlipOffOutwards);
Assert.IsFalse(result.MergeGrassCoverSlipOffInwards);
Assert.IsFalse(result.MergeHeightStructures);
Assert.IsFalse(result.MergeClosingStructures);
Assert.IsFalse(result.MergePipingStructure);
Assert.IsFalse(result.MergeStabilityPointStructures);
Assert.IsFalse(result.MergeDuneErosion);
CollectionAssert.IsEmpty(result.MergeSpecificFailureMechanisms);
}
}
public void Can_send_brand_message(MessageDeliveryMethod messageDeliveryMethod)
{
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
_emailNotificationWorker.Start();
}
else
{
_smsNotificationWorker.Start();
}
if (messageDeliveryMethod == MessageDeliveryMethod.Email)
{
MessageTemplateService.TrySendBrandEmail(
TestDataGenerator.GetRandomString(),
TestDataGenerator.GetRandomEmail(),
Brand.Id,
MessageType.ReferFriends,
new ReferFriendsModel());
}
else
{
MessageTemplateService.TrySendBrandSms(
TestDataGenerator.GetRandomString(),
TestDataGenerator.GetRandomPhoneNumber(),
Brand.Id,
MessageType.ReferFriends,
new ReferFriendsModel());
}
var events = _eventRepository.GetEvents <NotificationSentEvent>().ToArray();
Assert.That(events.Length, Is.EqualTo(1));
var notificationType = messageDeliveryMethod == MessageDeliveryMethod.Email
? NotificationType.Email
: NotificationType.Sms;
Assert.That(events.First().Type, Is.EqualTo(notificationType));
Assert.That(events.First().Status, Is.EqualTo(NotificationStatus.Send));
}
public void Update_LocationsWithOutput_ClearOutputAndReturnChangedObjects()
{
// Setup
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
var handler = new HydraulicLocationConfigurationDatabaseUpdateHandler(assessmentSection);
IEnumerable <HydraulicBoundaryLocationCalculation> locations = GetLocationCalculations(assessmentSection);
IEnumerable <DuneLocationCalculation> duneLocations = GetDuneLocationCalculations(assessmentSection);
ICalculation[] calculationsWithOutput = assessmentSection.GetFailureMechanisms()
.OfType <ICalculatableFailureMechanism>()
.SelectMany(fm => fm.Calculations)
.Where(c => c.HasOutput)
.ToArray();
calculationsWithOutput = calculationsWithOutput.Except(calculationsWithOutput.OfType <SemiProbabilisticPipingCalculationScenario>()
.Where(c => c.InputParameters.UseAssessmentLevelManualInput))
.Except(calculationsWithOutput.OfType <MacroStabilityInwardsCalculationScenario>()
.Where(c => c.InputParameters.UseAssessmentLevelManualInput))
.Except(calculationsWithOutput.OfType <TestPipingCalculationScenario>())
.ToArray();
// Precondition
Assert.IsTrue(locations.All(l => l.HasOutput));
Assert.IsTrue(duneLocations.All(l => l.Output != null));
// Call
IEnumerable <IObservable> changedObjects = handler.Update(assessmentSection.HydraulicBoundaryDatabase, null, false, "some/file/path");
// Assert
Assert.IsTrue(locations.All(l => !l.HasOutput));
Assert.IsTrue(duneLocations.All(l => l.Output == null));
Assert.IsTrue(calculationsWithOutput.All(c => !c.HasOutput));
IEnumerable <IObservable> expectedChangedObjects = new IObservable[]
{
assessmentSection.HydraulicBoundaryDatabase
}.Concat(locations).Concat(duneLocations).Concat(calculationsWithOutput);
CollectionAssert.AreEquivalent(expectedChangedObjects, changedObjects);
}
public void ApplyFiltersShouldHandlePrimitiveCollectionTypes()
{
IQueryable <TestModel> currentSet = TestDataGenerator.CreateSampleSet();
var filters = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Value = new DynamicQueryOptions
{
Filters = new List <Filter>
{
new Filter
{
Operator = FilterOperation.Equals,
PropertyName = "_",
Value = "3"
}
}
},
PropertyName = nameof(TestModel.InnerPrimitiveList),
Operator = FilterOperation.Any
}
},
SortOptions = new List <SortOption>
{
new SortOption
{
PropertyName = nameof(TestModel.Age)
}
}
};
List <TestModel> result = currentSet.ApplyFilters(filters).ToList();
Assert.NotEmpty(result);
Assert.Equal(2, result.Count);
Assert.Equal(currentSet.ElementAtOrDefault(0), result[0]);
Assert.Equal(currentSet.ElementAtOrDefault(1), result[1]);
}
static void Main(string[] args)
{
TestDataGenerator tdg = new TestDataGenerator();
tdg.Generate <Person2>(100,
p =>
{
p.FirstName = tdg.Random(Source.FirstName, 10);
p.LastName = tdg.Random(Source.LastName);
//p.Sex = tdg.Random(new char[] { 'M', 'F' });
p.State = tdg.Random(Source.USState);
p.ZipCode = tdg.Random(Source.USZipCode);
p.Phone = tdg.RandomFormatted("000.0000");
p.ItemName = tdg.Random(Source.WidgetName);
if (p.FirstName != null)
{
p.Email = $"{p.FirstName.ToLower()}.{p.LastName.ToLower()}@{tdg.Random(Source.DomainName)}";
}
p.Sex = tdg.RandomWeighted(new SexWeighted[]
{
new SexWeighted()
{
Letter = 'M', Factor = 3
},
new SexWeighted()
{
Letter = 'F', Factor = 1
}
}, m => m.Letter);
p.SomeDate = tdg.RandomInRange(0, 30, i => new DateTime(2003, 1, 1).AddDays(i));
}, records =>
{
Console.WriteLine("--- batch ---");
foreach (var record in records)
{
Console.WriteLine($"first = {record.FirstName}, last = {record.LastName}, email = {record.Email}, someDate = {record.SomeDate}");
}
});
Console.ReadLine();
}
static void ImportTestBins()
{
using(TestDataGenerator gen = new TestDataGenerator()) {
CloudImporter.ImportClouds();
}
}
static void GenerateBin()
{
using(TestDataGenerator gen = new TestDataGenerator()) {
string name = string.Format("{0}_{1}", Random.value * 360 - 180, Random.value * 360 - 180);
gen.GenerateBin(name, 1000, 20);
}
}
static void UnimportTestBins()
{
using(TestDataGenerator gen = new TestDataGenerator()) {
foreach(string fname in Directory.GetFiles(ExplodedPrefs.ImportedPath,"*.bin")) {
string cloud = ExplodedPrefs.ImportedCloud(fname);
if (File.Exists( cloud )) {
Debug.Log(string.Format("Unimporting {0} .bin + .cloud", Path.GetFileNameWithoutExtension(fname)));
FileUtil.MoveFileOrDirectory(fname,ExplodedPrefs.IncomingBin(fname));
FileUtil.MoveFileOrDirectory(cloud,ExplodedPrefs.IncomingCloud(cloud));
} else {
Debug.LogWarning(string.Format("Removing {0} - no corresponding .cloud found", Path.GetFileName(fname)));
FileUtil.DeleteFileOrDirectory(fname);
}
}
// remove clouds with no corresponding bin
foreach(string fname in Directory.GetFiles(ExplodedPrefs.ImportedPath,"*.cloud")) {
FileUtil.DeleteFileOrDirectory(fname);
Debug.LogWarning(string.Format("Removing {0} - no corresponding .bin found", Path.GetFileName(fname)));
}
foreach(string fname in Directory.GetFiles(ExplodedPrefs.PrefabsPath,"*.prefab")) {
Debug.Log(string.Format("Removing {0} (unimport)", Path.GetFileName(fname)));
FileUtil.DeleteFileOrDirectory(fname);
}
AssetDatabase.Refresh();
}
}
static void CompactTestBins()
{
using(TestDataGenerator gen = new TestDataGenerator()) {
CloudCompactor.CompactClouds();
}
}
static void AttachTestSounds()
{
using(TestDataGenerator gen = new TestDataGenerator()) {
CloudCompactor.AttachSounds();
}
}
