public void CustomerDelete()
{
var db = new TestDb();
db.AddSet(TestData.Customers);
// Arrange
CustomerController controller = new CustomerController(db);
CustomerModel testCustomer = new CustomerModel();
testCustomer.Id = 8;
testCustomer.Email = "*****@*****.**";
testCustomer.FirstName = "User First Name";
testCustomer.MiddleName = "User Middle Name";
testCustomer.LastName = "User Last Name";
testCustomer.Gender = "M";
testCustomer.Address = "The World";
testCustomer.BirthDate = DateTime.UtcNow.Date;
testCustomer.MaritalStatus = "M";
testCustomer.SourceOfIncome = "Employed";
testCustomer.IsDeleted = false;
testCustomer.CreateDate = DateTime.UtcNow.Date;
testCustomer.UpdateDate = DateTime.UtcNow.Date;
// Act
// var result = controller.Delete(testCustomer);
// Assert
//Assert.IsNotNull(result);
}
static void Main(string[] args)
{
Log.Info("Connecting to Redis");
Redis redis = new Redis();
redis.Start();
Log.Info("Creating Test Database");
TestDb.Create();
Log.Info("Starting Server");
var server = new Server(SERVER_PORT);
server.StartListeningForPackets();
server.StartGameThread();
// Make the server thread join this thread so the code execution dont stop here
//server.TcpHandler.connectionsThread.Join();
while (server.IsRunning())
{
string consoleInput = Console.ReadLine();
string[] split = consoleInput.Split(" ");
string cmd = split[0];
var cmdArgs = split.Skip(1).ToArray();
if (cmd == "help")
{
Log.Info("Registered Commands:", ConsoleColor.Green);
var allCommands = Server.CommandHandler.RegisteredCommands();
var output = "help |";
foreach (var command in allCommands)
{
output += $" {command} |";
}
Log.Info(output, ConsoleColor.Green);
}
if (!Server.CommandHandler.RunCommand(cmd, cmdArgs))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Log.Error("[Console] Command Not Found. Use 'help' for help");
}
}
}
public async void PostEditSuccess()
{
using (var database = new TestDb())
{
var controller = new BreedsController(database.Context);
IActionResult result = await controller.Edit(6, new Breed(6, "Modified Breed"));
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Breed breed = database.Context.Breeds.SingleOrDefault(b => b.Id == 6);
Assert.Equal("Modified Breed", breed.Name);
}
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_player = new StoredPlayer()
{
UserId = "wololo",
Login = "******",
Password = "******",
MoveSpeed = 1,
X = 5,
Y = 5
};
}
public void Prepare()
{
_server = new Server(8886);
_server.StartListeningForPackets();
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_client = new ConnectedClientTcpHandler()
{
TcpClient = new TcpClient("localhost", 8886),
ConnectionId = Guid.NewGuid().ToString()
};
}
public void DbIndexAttribute_sql_generation()
{
using (var testDb = new TestDb(SqlVersion.Sql13))
{
var command = testDb.GetCreateTableCommand(testDb.TestTable._, false);
var expectedSql =
@"CREATE TABLE [TestTable] (
[Id] INT NULL,
[Value] INT NULL
INDEX [IDX_ID] UNIQUE NONCLUSTERED ([Id] ASC),
INDEX [IDX_ID_VALUE] NONCLUSTERED ([Id], [Value] DESC)
);
";
Assert.AreEqual(expectedSql, command.CommandText);
}
}
public async void PostCreateSuccess()
{
using (var database = new TestDb())
{
var controller = new BreedsController(database.Context);
IActionResult result = await controller.Create(new Breed("Test Breed 11"));
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Breed breed = database.Context.Breeds.LastOrDefault();
Assert.Equal("Test Breed 11", breed.Name);
}
}
public async void PostCreateParentBreedNull()
{
using (var database = new TestDb())
{
var controller = new BreedsController(database.Context);
IActionResult result = await controller.Create(new Breed { Name = "Test Breed with Null Parent Breed", BreedId = null });
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Breed breed = database.Context.Breeds.LastOrDefault();
Assert.Equal("Test Breed with Null Parent Breed", breed.Name);
}
}
public async void PostEditSaved()
{
using (var database = new TestDb())
{
var controller = new IndividualsController(database.Context);
IActionResult result = await controller.Edit(6, new Individual(6, "Modified Individual", 4));
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Individual individual = database.Context.Individuals.SingleOrDefault(b => b.Id == 6);
Assert.Equal("Modified Individual", individual.Name);
}
}
public async void PostEditParentBreedZero()
{
using (var database = new TestDb())
{
var controller = new BreedsController(database.Context);
IActionResult result = await controller.Edit(1, new Breed { Id = 1, Name = "Test Modified Breed with Zero Parent Breed", BreedId = 0 });
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Breed breed = database.Context.Breeds.SingleOrDefault(b => b.Name == "Test Modified Breed with Zero Parent Breed");
Assert.Equal(1, breed.Id);
}
}
public async void PostEditParentBreedNull()
{
using (var database = new TestDb())
{
var controller = new BreedsController(database.Context);
IActionResult result = await controller.Edit(10, new Breed { Id = 10, Name = "Test Breed with Null Parent Breed", BreedId = null });
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Breed breed = database.Context.Breeds.SingleOrDefault(b => b.Id == 10);
Assert.Equal("Test Breed with Null Parent Breed", breed.Name);
}
}
private static string[] Act(string[] userNames, string ascDesc)
{
var db = new TestDb();
db.CreateCollation(new Utf8Collation());
db.Execute("create table Users(Name varchar collate " + Utf8Collation.Collation_Name + ")");
foreach (var name in userNames)
{
db.Execute("insert into Users(Name) values(?)", name);
}
var users = db.Query <User>("select Name from Users order by Name " + ascDesc + ";");
var names = users.Select(s => s.Name).ToArray();
return(names);
}
public async void TestCreateAgreement_WithLimitsClause()
{
// Arrange
var service = CreateService();
var enrollee = new EnrolleeFactory().Generate();
var noteText = "oh dear";
enrollee.AccessAgreementNote = new AccessAgreementNote {
Note = noteText
};
TestDb.Has(enrollee);
// Act
await service.CreateEnrolleeAgreementAsync(enrollee.Id);
// Assert
AssertAgreementGeneration(enrollee, expectedLimitsClauseText: noteText);
}
public async void TestGpidValidation_MatchesEmail()
{
// Arrange
var service = CreateService();
var enrollee = TestDb.HasAnEnrollee("default,status.editable");
var request = new GpidValidationParameters()
{
Email = enrollee.Email
};
// Act
var response = await service.ValidateProvisionerDataAsync(enrollee.GPID, request);
// Assert
Assert.NotNull(response);
Assert.True(response.AllPropertiesNullExcept(nameof(response.Email)));
Assert.Equal(GpidValidationResponse.MatchText, response.Email);
}
public async void PostCreateWithParentBreedSuccess()
{
using (var database = new TestDb())
{
var controller = new BreedsController(database.Context);
IActionResult result = await controller.Create(new Breed { Name = "Test Breed with Parent Breed", BreedId = 1 });
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Breed breed = database.Context.Breeds.SingleOrDefault(b => b.Name == "Test Breed with Parent Breed");
Assert.Equal("Test Breed with Parent Breed", breed.Name);
Assert.Equal(1, breed.ParentBreed.Id);
}
}
public ActionResult Delete(int id)
{
TestDb db = new TestDb();
Test1 stu = (from s in db.Tests
where s.Id == id
select s).FirstOrDefault();
try
{
db.Tests.Remove(stu);
db.SaveChanges();
}
catch (Exception e)
{
}
return(View(stu));
}
public void UseColumnNamingConvention_Should_ApplyNamingConventionForTableNameForNestedOwnedType_When_ParticularNamingConventionIsSpecified()
{
// Given
using var db = new TestDb(_options, builder => builder.UseColumnNamingConvention(NamingConvention.LowerSnakeCase));
// When
var model = db.Model.FindEntityType(typeof(TestEntity));
// Then
db.Model
.GetEntityTypes()
.Where(e => e.ClrType == typeof(OwnedEntity))
.SelectMany(p => p.GetProperties())
.Where(p => !p.IsPrimaryKey() && p.DeclaringEntityType.DefiningEntityType.ClrType == typeof(NestedOwnedEntity) && p.Name == "Code")
.Select(p => p.GetColumnName())
.First()
.Should().Be("nested_field_a_nested_field_a_code");
}
public void ImportCreatedWithParentBreed()
{
using (var database = new TestDb())
{
var loader = new DataLoader(database.Context);
loader.ImportBreeds(Encoding.ASCII.GetBytes(@"{""bulldog"": [""boston"", ""french""]}"));
Breed bulldog = database.Context.Breeds.SingleOrDefault(b => b.Name == "Bulldog");
Assert.NotNull(bulldog);
Breed boston = database.Context.Breeds.SingleOrDefault(b => b.Name == "Boston");
Assert.NotNull(boston);
Assert.Equal(boston.BreedId, bulldog.Id);
}
}
public async void testMaxViews()
{
int tokenMaxViews = 3;
Enrollee enrollee = TestDb.Has(TestUtils.EnrolleeFaker.Generate());
var service = CreateService();
EnrolmentCertificateAccessToken token = await service.CreateCertificateAccessTokenAsync(enrollee);
Assert.NotNull(token);
Assert.Equal(0, token.ViewCount);
for (int view = 1; view <= tokenMaxViews; view++)
{
Assert.NotNull(await service.GetEnrolmentCertificateAsync(token.Id));
Assert.Equal(view, token.ViewCount);
}
Assert.Null(await service.GetEnrolmentCertificateAsync(token.Id));
}
public void Start()
{
Redis redis = new Redis();
redis.Start();
TestDb.Create();
_server = new Server(new ServerStartConfig()
{
Port = 123
});
_server.StartGameThread();
_player = new StoredPlayer()
{
UserId = "wololo",
Login = "******",
Password = "******"
};
}
public async void TestGpidValidation_Birthdate(bool requestMatches)
{
// Arrange
var service = CreateService();
var enrollee = TestDb.HasAnEnrollee("default,status.editable");
var request = new GpidValidationParameters()
{
DateOfBirth = enrollee.DateOfBirth.AddDays(requestMatches ? 0 : 2)
};
var expectedText = requestMatches ? GpidValidationResponse.MatchText : GpidValidationResponse.NoMatchText;
// Act
var response = await service.ValidateProvisionerDataAsync(enrollee.GPID, request);
// Assert
Assert.NotNull(response);
Assert.True(response.AllPropertiesNullExcept(nameof(response.DateOfBirth)));
Assert.Equal(expectedText, response.DateOfBirth);
}
public async void TestGpidValidation_NoParams()
{
// Arrange
var service = CreateService();
var enrollee = TestDb.HasAnEnrollee("default,status.editable");
var request = new GpidValidationParameters();
// Act
var response = await service.ValidateProvisionerDataAsync(enrollee.GPID, request);
// Assert
Assert.NotNull(response);
foreach (var property in typeof(GpidValidationParameters).GetProperties())
{
var responseProp = typeof(GpidValidationResponse).GetProperty(property.Name);
Assert.NotNull(responseProp);
Assert.Null(responseProp.GetValue(response));
}
}
public async void TestSendEnrolleeRenewalEmails(int daysUntilExpiry, ExpectedEmail expected)
{
// Arrange
var requiredEmail = new Email("f@f", "t@t", "Required", "");
var passedEmail = new Email("f@f", "t@t", "Passed", "");
var smtpEmailClient = A.Fake <ISmtpEmailClient>();
var emailRenderingService = A.Fake <IEmailRenderingService>();
A.CallTo(() => emailRenderingService.RenderRenewalRequiredEmailAsync(A <string> ._, A <EnrolleeRenewalEmailViewModel> ._)).Returns(requiredEmail);
A.CallTo(() => emailRenderingService.RenderRenewalPassedEmailAsync(A <string> ._, A <EnrolleeRenewalEmailViewModel> ._)).Returns(passedEmail);
var service = CreateService(emailRenderingService: emailRenderingService, smtpEmailClient: smtpEmailClient);
var enrollee = TestDb.HasAnEnrollee();
enrollee.Agreements = new[]
{
new Agreement
{
AcceptedDate = DateTimeOffset.Now,
ExpiryDate = DateTimeOffset.Now.AddDays(daysUntilExpiry)
}
};
TestDb.SaveChanges();
// Act
await service.SendEnrolleeRenewalEmails();
// Assert
if (expected == ExpectedEmail.Passed)
{
A.CallTo(() => smtpEmailClient.SendAsync(passedEmail)).MustHaveHappened();
}
else if (expected == ExpectedEmail.Required)
{
A.CallTo(() => smtpEmailClient.SendAsync(requiredEmail)).MustHaveHappened();
}
else
{
A.CallTo(() => smtpEmailClient.SendAsync(A <Email> ._)).MustNotHaveHappened();
}
}
public async void PostDeleteConfirmSuccess()
{
using (var database = new TestDb())
{
Assert.True(database.Context.Breeds.Any(i => i.Id == 9));
Assert.False(database.Context.Breeds.Any(b => b.BreedId == 9));
Assert.False(database.Context.Individuals.Any(b => b.BreedId == 9));
var controller = new BreedsController(database.Context);
IActionResult result = await controller.DeleteConfirmed(9);
RedirectToActionResult redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirect.ActionName);
Assert.False(database.Context.Breeds.Any(i => i.Id == 9));
}
}
public async void TestCreateAgreement_Obo(CareSettingType careSetting)
{
// Arrange
var service = CreateService();
var enrollee = new EnrolleeFactory().Generate();
enrollee.EnrolleeCareSettings.Single().CareSettingCode = (int)careSetting;
enrollee.Certifications.Clear();
enrollee.AccessAgreementNote = null;
TestDb.Has(enrollee);
var expectedAgreementId = TestDb.AgreementVersions.GetNewestIdOfType <OboAgreement>();
// Act
await service.CreateEnrolleeAgreementAsync(enrollee.Id);
// Assert
AssertAgreementGeneration(enrollee, expectedAgreementId);
}
public void Insert_RollbackWithTransactionScope_RecordsAreRolledBackWhenDisposed()
{
var personRecords = new dynamic[]
{
new
{
FirstName = "John",
LastName = "Doe",
MiddleInitial = "A",
Age = 50,
DateOfBirth = DateTime.Parse("2000-01-01"),
Gender = Gender.Male
}
};
var addressRecords = new dynamic[]
{
new
{
PersonId = 1,
Street = "123 Fake St.",
Apt = (string)null,
City = "Nuketown",
State = "WI",
ZipCode = "51234"
}
};
using (var testDb = new TestDb(DynamicDbTests.DbConnectionString, rollbackWithTransactionScope: true))
{
var insertedPersonRecords = testDb.Insert("dbo.Person", personRecords);
var insertedAddressRecords = testDb.Insert("dbo.Address", addressRecords);
Assert.AreEqual(1, insertedPersonRecords.Length);
Assert.AreEqual(1, insertedPersonRecords[0].Id);
DynamicDbTests.AssertPersonRecordMatches(personRecords[0], insertedPersonRecords[0]);
DynamicDbTests.AssertPersonRecordsExistAndMatch(personRecords);
}
DynamicDbTests.AssertPersonRecordsDoNotExist(1);
DynamicDbTests.AssertAddressRecordsDoNotExist(1);
}
public async void TestCreateAgreement_LicencedObo(CareSettingType careSetting)
{
// Arrange
var service = CreateService();
var enrollee = new EnrolleeFactory().Generate();
enrollee.EnrolleeCareSettings.Single().CareSettingCode = (int)careSetting;
enrollee.Certifications = new CertificationFactory(enrollee).Generate(1, "default,licence.nonRegulated");
enrollee.AccessAgreementNote = null;
TestDb.Has(enrollee);
TestDb.Entry(enrollee.Certifications.Single()).Reference(c => c.License).Load();
var expectedAgreementId = TestDb.AgreementVersions.GetNewestIdOfType <OboAgreement>();
// Act
await service.CreateEnrolleeAgreementAsync(enrollee.Id);
// Assert
AssertAgreementGeneration(enrollee, expectedAgreementId);
}
public void OneTimeSetupBase()
{
// Run the Web app in a local Web server
this.testDb = new TestDb();
this.testEventuresApp = new TestEventuresApp <Startup>(
testDb, "../../../../Eventures.WebApp");
this.baseUrl = this.testEventuresApp.ServerUri;
// Setup the ChromeDriver
var chromeOptions = new ChromeOptions();
if (!Debugger.IsAttached)
{
chromeOptions.AddArguments("headless");
}
this.driver = new ChromeDriver(chromeOptions);
// Set an implicit wait for the UI interaction
this.driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(5);
}
public async void TestGpidValidation_NoMatch()
{
// Arrange
var service = CreateService();
var enrollee = TestDb.HasAnEnrollee("default,status.editable");
enrollee.SmsPhone = null;
var request = new GpidValidationParameters()
{
MobilePhone = "1-800-COOL-ENROLLEE"
};
// Act
var response = await service.ValidateProvisionerDataAsync(enrollee.GPID, request);
// Assert
Assert.NotNull(response);
Assert.True(response.AllPropertiesNullExcept(nameof(response.MobilePhone)));
Assert.Equal(GpidValidationResponse.MissingText, response.MobilePhone);
}
public DatabaseTests()
{
var builder = new SqlConnectionStringBuilder();
builder.DataSource = "localhost";
builder.InitialCatalog = "master";
builder.UserID = "sa";
builder.Password = "******";
_masterCs = builder.ToString();
using (var masterCon = new DataConnection(ProviderName.SqlServer2014, _masterCs))
{
masterCon.Execute("CREATE DATABASE Linq2dbTests");
}
builder.InitialCatalog = "Linq2dbTests";
_dbCs = builder.ToString();
using (var con = new TestDb(ProviderName.SqlServer2014, _dbCs))
con.CreateTable <CtTest>();
}
public async void TestCreateAgreement_ThrowsWhenNull()
{
// Arrange
var service = CreateService();
var enrollee = new EnrolleeFactory().Generate();
enrollee.Submissions = new[]
{
new Submission
{
AgreementType = null,
CreatedDate = DateTimeOffset.Now,
}
};
enrollee.AccessAgreementNote = null;
TestDb.Has(enrollee);
// Act
// Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => service.CreateEnrolleeAgreementAsync(enrollee.Id));
}
public void CustomerRetrieveById()
{
var db = new TestDb();
var username = "******";
db.AddSet(TestData.Customers);
// Arrange
CustomerController controller = new CustomerController(db);
// Act
var result = controller.Get(username);
// Assert
Assert.IsNotNull(result);
}
public void CustomerRetrieveAll()
{
var db = new TestDb();
db.AddSet(TestData.Customers);
// Arrange
CustomerController controller = new CustomerController(db);
// Act
IEnumerable<CustomerModel> result = controller.Get();
// Assert
Assert.IsNotNull(result);
}
public MsSqlServerSqlStringTests()
{
SqlStrings = new MsSqlServerSqlStrings();
Db = new TestDb(TestConfiguration.MsSql2008TestConnectionString, DbClientTypeName.MsSql);
}
public OracleSqlStringTests()
{
SqlStrings = new OracleSqlStrings();
Db = new TestDb(TestConfiguration.OracleTestConnectionString, DbClientTypeName.OracleDataAccess);
}
