public void DoesNotSendMessageIfUserIsNotConfirmedOrIfEmailDoesNotMatchUser(int userId, string submittedEmail, bool isConfirmed)
{
var webSecurity = Substitute.For<IWebSecurityService>();
webSecurity.GetUserId("haacked").Returns(userId);
webSecurity.IsConfirmed("haacked").Returns(isConfirmed);
var messengerService = Substitute.For<IMessengerService>();
var users = new TestDbSet<User> { new User { Id = 42, Name = "haacked", Email = "*****@*****.**" }, new User() };
var tournamentContext = Substitute.For<ITournamentContext>();
tournamentContext.Users.Returns(users);
var accountController = new AccountController(webSecurity, messengerService, tournamentContext);
var request = Substitute.For<HttpRequestBase>();
request.Url.Returns(new Uri("http://localhost/"));
var httpContext = Substitute.For<HttpContextBase>();
httpContext.Request.Returns(request);
accountController.ControllerContext = new ControllerContext(httpContext, new RouteData(), accountController);
var forgotPasswordModel = new ForgotPasswordModel
{
UserName = "******",
Email = submittedEmail
};
accountController.ForgotPassword(forgotPasswordModel);
messengerService.DidNotReceive().Send(Args.String, Args.String, Args.String, Args.String, Args.Boolean);
}
public void SendsResetMessageIfUserIsConfirmedAndEmailMatchesUserEmail()
{
var webSecurity = Substitute.For<IWebSecurityService>();
webSecurity.GetUserId("haacked").Returns(42);
webSecurity.IsConfirmed("haacked").Returns(true);
var messengerService = Substitute.For<IMessengerService>();
var users = new TestDbSet<User> { new User { Id = 42, Name = "haacked", Email = "*****@*****.**" }, new User() };
var tournamentContext = Substitute.For<ITournamentContext>();
tournamentContext.Users.Returns(users);
var accountController = new AccountController(webSecurity, messengerService, tournamentContext);
var request = Substitute.For<HttpRequestBase>();
request.Url.Returns(new Uri("http://localhost/"));
var httpContext = Substitute.For<HttpContextBase>();
httpContext.Request.Returns(request);
accountController.ControllerContext = new ControllerContext(httpContext, new RouteData(), accountController);
var forgotPasswordModel = new ForgotPasswordModel
{
UserName = "******",
Email = "*****@*****.**"
};
accountController.ForgotPassword(forgotPasswordModel);
messengerService.Received().Send(Args.String, Args.String, Args.String, Args.String, Args.Boolean);
}
public void RegUser_ShouldAddUser()
{
var users = new TestDbSet<User>();
users.RegUser("ivan", "ivan");
Assert.AreEqual(users.Count(), 1);
Assert.AreEqual(users.FirstOrDefault().Name, "ivan");
}
public void Auth_ShouldReturnNull_IfNotFound()
{
var users = new TestDbSet<User>();
var user = users.Auth("ivan", "ivan");
Assert.IsNull(user);
}
/// <summary>
/// Конструктор.
/// </summary>
public TestToDoAppContext()
{
ColorClasses = new TestDbSet<ColorClass>();
Goals = new TestDbSet<Goal>();
IconClasses = new TestDbSet<IconClass>();
States = new TestDbSet<State>();
SubTasks = new TestDbSet<SubTask>();
Tasks = new TestDbSet<Task>();
}
public SwashbuckleODataContext() : base("name=SwashbuckleODataContext")
{
Customers = new TestDbSet<Customer>();
Orders = new TestDbSet<Order>();
Clients = new TestDbSet<Client>();
Projects = new TestDbSet<Project>();
Seed(this);
}
public void Auth_ShouldReturnNull_IfWrongPass()
{
var users = new TestDbSet<User>();
users.RegUser("ivan", "ivan");
var user = users.Auth("ivan", "ad");
Assert.IsNull(user);
}
public TestMedAgendaDbContext()
{
Appointments = new TestDbSet<Appointment>();
DoctorChecks = new TestDbSet<DoctorCheck>();
Doctors = new TestDbSet<Doctor>();
EmergencyContacts = new TestDbSet<EmergencyContact>();
ExamRooms = new TestDbSet<ExamRoom>();
PatientChecks = new TestDbSet<PatientCheck>();
Patients = new TestDbSet<Patient>();
Specialties = new TestDbSet<Specialty>();
}
public void Execute_ConsidersMultipleSearchTerms()
{
DbSet<Link> testDbSet = new TestDbSet<Link>();
var firstLinkToFind = new Link {Url = "http://bar.foo"};
testDbSet.Add(firstLinkToFind);
var secondLinkToFind = new Link {Name = "bar"};
testDbSet.Add(secondLinkToFind);
IQueryable<Link> results = StringQuery.Execute(testDbSet, new[] {"bar"});
Assert.AreEqual(2, results.Count());
}
public void Execute_ConsidersUrl()
{
DbSet<Link> testDbSet = new TestDbSet<Link>();
var linkToFind = new Link {Url = "http://bar.foo"};
testDbSet.Add(linkToFind);
var otherLink = new Link {Url = "foo"};
testDbSet.Add(otherLink);
IQueryable<Link> results = StringQuery.Execute(testDbSet, new[] {"bar"});
Assert.AreEqual(1, results.Count());
Assert.AreEqual(linkToFind, results.First());
}
public void Auth_ShouldReturnRightUser()
{
var users = new TestDbSet<User>();
users.RegUser("ivan", "ivan");
users.RegUser("petya", "admin");
users.RegUser("admin", "admin1");
var user1 = users.Auth("ivan", "ivan");
var user2 = users.Auth("petya", "admin");
var user3 = users.Auth("admin", "admin1");
Assert.AreEqual(user1.Name, "ivan");
Assert.AreEqual(user2.Name, "petya");
Assert.AreEqual(user3.Name, "admin");
}
public void DeleteInvoiceHeader()
{
var testDbSet = new TestDbSet<InvoiceHeader>(_dataCollection);
var testInvoiceHeaderDao = new TestInvoiceHeaderDao(testDbSet);
var invoiceHeaderToRemove = new InvoiceHeader
{
Id = 1,
Customer = "TestCustomer",
InvoiceDateTime = DateTime.MinValue,
InvoiceNumber = 1,
Supplier = "TestSupplier",
Tax = 0,
Total = 100
};
testInvoiceHeaderDao.Delete(invoiceHeaderToRemove);
Assert.IsFalse(testDbSet.DataCollection.Contains(invoiceHeaderToRemove));
}
public void AddInvoiceHeader()
{
var testDbSet = new TestDbSet<InvoiceHeader>(_dataCollection);
var testInvoiceHeaderDao = new TestInvoiceHeaderDao(testDbSet);
var invoiceHeaderToAdd = new InvoiceHeader
{
Id = 4,
Customer = "TestCustomer3",
InvoiceDateTime = DateTime.MinValue,
InvoiceNumber = 5,
Supplier = "TestSupplier3",
Tax = 80,
Total = 9000
};
testInvoiceHeaderDao.Write(invoiceHeaderToAdd);
Assert.IsTrue(testDbSet.DataCollection.Contains(invoiceHeaderToAdd));
}
public void Retrieve_GivenQuestionAnswerByIdQuery_ContextShouldBeQueriedAndQuestionAnswerReturned()
{
var questionAnswerId = Guid.NewGuid();
var set = new TestDbSet <QuestionAnswer> {
new QuestionAnswer()
{
QuestionAnswerId = questionAnswerId
}
};
A.CallTo(() => _fakeContext.Set <QuestionAnswer>()).Returns(set);
var query = new QuestionAnswerByIdQuery()
{
QuestionAnswerId = questionAnswerId
};
var questionAnswer = _queryHandler.Retrieve(query);
questionAnswer.Should().NotBeNull();
}
public void Retrieve_GivenAssessmentByPatientIdQueryAndPatientDoesNotExist_ContextShouldBeQueriedAndAssessmentItemsEmpty()
{
var patientId = Guid.NewGuid();
var set = new TestDbSet <Assessment> {
new Assessment()
{
Patient = new Patient()
}
};
A.CallTo(() => _fakeContext.Set <Assessment>()).Returns(set);
var query = new AssessmentsByPatientIdQuery()
{
PatientId = patientId
};
var assessment = _queryHandler.Retrieve(query);
assessment.Items.Should().HaveCount(0);
}
public void Retrieve_GivenWorkflowVersionByIdQuery_ContextShouldBeQueriedAndWorkflowVersionReturned()
{
var id = Guid.NewGuid();
var set = new TestDbSet <WorkflowVersion> {
new WorkflowVersion()
{
WorkflowVersionId = id
}
};
A.CallTo(() => _fakeContext.Set <WorkflowVersion>()).Returns(set);
var query = new WorkflowVersionByIdQuery()
{
WorkflowVersionId = id
};
var workflowVersion = _queryHandler.Retrieve(query);
workflowVersion.Should().NotBeNull();
}
public async void GetAll_ShouldReturnAllUsersFromDatabase()
{
var loggerMock = new Mock <ILogger <UserService> >();
var contextMock = new Mock <IDatabaseContext>();
var user1 = GetUserSample("name", "password");
var user2 = GetUserSample("name2", "password2");
var dbSet = new TestDbSet <User>();
dbSet.Add(user1);
dbSet.Add(user2);
contextMock.Setup(x => x.Users)
.Returns(dbSet);
var userService = new UserService(loggerMock.Object, contextMock.Object);
var result = await userService.GetAllAsync();
Assert.Contains(user1, result);
Assert.Contains(user2, result);
}
public void TestRetrieveParentTasks_Success(BenchmarkContext benchContext)
{
var context = new MockProjectManagerEntities();
var parentTasks = new TestDbSet <DAC.ParentTask>();
parentTasks.Add(new DAC.ParentTask()
{
Parent_ID = 12345,
Parent_Task_Name = "PTASK"
});
parentTasks.Add(new DAC.ParentTask()
{
Parent_ID = 123456,
Parent_Task_Name = "MYTASK"
});
context.ParentTasks = parentTasks;
var controller = new TaskController(new BC.TaskBC(context));
var result = controller.RetrieveParentTasks() as JSendResponse;
addCounter.Increment();
}
public async void Delete_ShouldRemoveUserFromDatabase_WhenUserHaSpecifiedId()
{
var loggerMock = new Mock <ILogger <UserService> >();
var contextMock = new Mock <IDatabaseContext>();
var user = GetUserSample("name", "password");
var dbSet = new TestDbSet <User>();
dbSet.Add(user);
contextMock.Setup(x => x.Users)
.Returns(dbSet);
contextMock.Setup(x => x.SaveChanges())
.Verifiable();
var userService = new UserService(loggerMock.Object, contextMock.Object);
await userService.DeleteAsync(user.Id);
Assert.True(!dbSet.Any(x => x.Id == user.Id));
contextMock.Verify(x => x.SaveChanges());
}
public async void Authenticate_ShouldReturnUser_WhenUsernameAndPasswordAreValid()
{
var contextMock = new Mock <IDatabaseContext>();
var loggerMock = new Mock <ILogger <UserService> >();
var username = "******";
var password = "******";
var user = GetUserSample(username, password);
var dbSet = new TestDbSet <User>();
dbSet.Add(user);
contextMock.Setup(x => x.Users)
.Returns(dbSet);
var userService = new UserService(loggerMock.Object, contextMock.Object);
var result = await userService.AuthenticateAsync(username, password);
Assert.True(result.Id == user.Id);
}
public void Retrieve_GivenAssessmentByIdQuery_ContextShouldBeQueriedAndAssessmentReturned()
{
var id = Guid.NewGuid();
var set = new TestDbSet <Assessment> {
new Assessment()
{
AssessmentId = id
}
};
A.CallTo(() => _fakeContext.Set <Assessment>()).Returns(set);
var query = new AssessmentByIdQuery()
{
AssessmentId = id
};
var assessment = _queryHandler.Retrieve(query);
assessment.Should().NotBeNull();
}
public void TestDeleteUser_Success()
{
var context = new MockProjectManagerEntities();
var users = new TestDbSet <DAC.User>();
users.Add(new DAC.User()
{
Employee_ID = "418220",
First_Name = "Prateek",
Last_Name = "Gangopadhyay",
Project_ID = 123,
Task_ID = 123,
User_ID = 418220
});
users.Add(new DAC.User()
{
Employee_ID = "503322",
First_Name = "Khushboo",
Last_Name = "Jain",
Project_ID = 1234,
Task_ID = 1234,
User_ID = 503322
});
context.Users = users;
var user = new Models.User();
user.FirstName = "Khushboo";
user.LastName = "Jain";
user.EmployeeId = "503322";
user.UserId = 503322;
var controller = new UserController(new BC.UserBC(context));
var result = controller.DeleteUserDetails(user) as JSendResponse;
Assert.IsNotNull(result);
Assert.AreEqual(context.Users.Local.Count, 1);
}
public void Execute_GivenAddUpdateDisclaimerCommandUpdate_DisclaimerShouldBeUpdatedInContext()
{
var disclaimerId = Guid.NewGuid();
var command = new AddUpdateDisclaimerCommand()
{
DisclaimerId = disclaimerId,
IsAgreed = true
};
var fakeContext = A.Fake<DbContext>();
var set = new TestDbSet<Disclaimer>() { new Disclaimer(){ DisclaimerId = disclaimerId} };
A.CallTo(() => fakeContext.Set<Disclaimer>()).Returns(set);
A.CallTo(() => _unitOfWork.Context).Returns(fakeContext);
_handler.Execute(command);
set.Count(x => x.DisclaimerId == disclaimerId).Should().Be(1);
var disclaimer = set.First(x => x.DisclaimerId == disclaimerId);
disclaimer.IsAgreed.Should().BeTrue();
}
public void Execute_GivenAddUpdateDisclaimerCommandAdd_DisclaimerShouldBeAddedToContext()
{
var disclaimerId = Guid.NewGuid();
var command = new AddUpdateDisclaimerCommand()
{
DisclaimerId = disclaimerId,
IsAgreed = true
};
var fakeContext = A.Fake<DbContext>();
var set = new TestDbSet<Disclaimer>();
A.CallTo(() => _userPrincipalProvider.CurrentUserName).Returns("user");
A.CallTo(() => fakeContext.Set<Disclaimer>()).Returns(set);
A.CallTo(() => _unitOfWork.Context).Returns(fakeContext);
_handler.Execute(command);
var disclaimer = set.First(x => x.DisclaimerId == disclaimerId);
disclaimer.AssessorDomainName.Should().Be("user");
disclaimer.IsAgreed.Should().BeTrue();
}
public void Retrieve_GivenAssessmentQuestionAnswerByAssessmentAndQuestionIdQuery_ContextShouldBeQueriedAndAssessmentReturned()
{
var assessmentId = Guid.NewGuid();
var workflowQuestionId = Guid.NewGuid();
var set = new TestDbSet <QuestionAnswer> {
new QuestionAnswer()
{
AssessmentId = assessmentId, WorkflowQuestionId = workflowQuestionId
}
};
A.CallTo(() => _fakeContext.Set <QuestionAnswer>()).Returns(set);
var query = new QuestionAnswerByAssessmentAndQuestionIdQuery()
{
AssessmentId = assessmentId, WorkflowQuestionId = workflowQuestionId
};
var questionAnswer = _queryHandler.Retrieve(query);
questionAnswer.Should().NotBeNull();
}
public void Execute_GivenRemoveAnswerCommandAndAnswerExists_AnswerShouldBeRemovedFromContext()
{
var questionAnswerId = Guid.NewGuid();
var fakeContext = A.Fake <DbContext>();
var set = new TestDbSet <QuestionAnswer> {
new QuestionAnswer()
{
QuestionAnswerId = questionAnswerId
}
};
A.CallTo(() => _unitOfWork.Context).Returns(fakeContext);
A.CallTo(() => fakeContext.Set <QuestionAnswer>()).Returns(set);
_handler.Execute(new RemoveAnswerCommand {
QuestionAnswerId = questionAnswerId
});
fakeContext.Set <QuestionAnswer>().FirstOrDefault(x => x.QuestionAnswerId == questionAnswerId)
.Should()
.BeNull();
}
public void Get_TestNotNullIfExists()
{
// Arrange
var packageNotificationTargets = new TestDbSet <PackageNotificationTargetEntity>
{
new PackageNotificationTargetEntity
{
Id = 1,
Type = PackageNotificationType.Email,
Value = "target"
}
};
_databaseContext.SetupGet(dc => dc.PackageNotificationTargets).Returns(packageNotificationTargets);
// Act
var retval = _packageNotificationTargetService.Object.Get(PackageNotificationType.Email, "target");
// Assert
Assert.IsNotNull(retval);
Assert.AreEqual(PackageNotificationType.Email, retval.Type);
Assert.AreEqual("target", retval.Value);
}
public void TestDeleteUser_Success(BenchmarkContext benchContext)
{
var context = new MockProjectManagerEntities();
var users = new TestDbSet <DAC.User>();
users.Add(new DAC.User()
{
Employee_ID = "418220",
First_Name = "Sweta",
Last_Name = "Misra",
Project_ID = 123,
Task_ID = 123,
User_ID = 418220
});
users.Add(new DAC.User()
{
Employee_ID = "503322",
First_Name = "ABC",
Last_Name = "XYZ",
Project_ID = 1234,
Task_ID = 1234,
User_ID = 503322
});
context.Users = users;
var user = new ProjectManager.Models.User();
user.FirstName = "ABC";
user.LastName = "XYZ";
user.EmployeeId = "503322";
user.UserId = 503322;
var controller = new UserController(new BC.UserBC(context));
var result = controller.DeleteUserDetails(user) as JSendResponse;
addCounter.Increment();
}
public void Execute_GivenUpdatePatientCommandUpdate_PatientShouldBeUpdatedInContext()
{
var patientId = Guid.NewGuid();
var fakeContext = A.Fake <DbContext>();
var set = new TestDbSet <Patient> {
new Patient()
{
PatientId = patientId
}
};
var command = new AddUpdatePatientCommand()
{
PatientId = patientId,
ClinicalSystemId = "clinicalsystemid",
NhsNumber = 123456789,
FirstName = "firstname",
LastName = "lastname",
DateOfBirth = new DateTime(2015, 1, 1),
GenderId = 1
};
A.CallTo(() => _unitOfWork.Context).Returns(fakeContext);
A.CallTo(() => fakeContext.Set <Patient>()).Returns(set);
_handler.Execute(command);
var patient = set.First(x => x.PatientId == patientId);
patient.ClinicalSystemId.Should().Be("clinicalsystemid");
patient.NhsNumber.Should().Be(123456789);
patient.FirstName.Should().Be("firstname");
patient.LastName.Should().Be("lastname");
patient.DateOfBirth.Should().Be(new DateTime(2015, 1, 1));
patient.GenderId.Should().Be(1);
}
public void Execute_GivenUpdateAssessmentCommandRoleChanged_AssessmentShouldBeUpdatedInContext()
{
var assessmentId = Guid.NewGuid();
var assessmentDate = new DateTime(2015, 1, 1);
const string decision = "decision";
var roleid = (int)RoleIdEnum.Assessor;
var decisionMaker = "Decision Maker Name";
var fakeContext = A.Fake <DbContext>();
var set = new TestDbSet <Assessment> {
new Assessment()
{
AssessmentId = assessmentId, RoleId = (int)RoleIdEnum.DecisionMaker
}
};
var command = new UpdateAssessmentCommand()
{
AssessmentId = assessmentId,
DateAssessmentStarted = assessmentDate,
Stage1DecisionToBeMade = decision,
RoleId = roleid,
DecisionMaker = decisionMaker
};
A.CallTo(() => _unitOfWork.Context).Returns(fakeContext);
A.CallTo(() => fakeContext.Set <Assessment>()).Returns(set);
_handler.Execute(command);
var assessment = set.First(x => x.AssessmentId == assessmentId);
assessment.DateAssessmentStarted.Should().Be(assessmentDate);
assessment.Stage1DecisionToBeMade.Should().Be(decision);
assessment.RoleId.Should().Be(roleid);
assessment.DecisionMaker.Should().Be(decisionMaker);
}
public void TestInsertTasks_Success(BenchmarkContext benchContext)
{
var context = new MockProjectManagerEntities();
var users = new TestDbSet <DAC.User>();
users.Add(new DAC.User()
{
Employee_ID = "414942",
First_Name = "Raj",
Last_Name = "Aryan",
User_ID = 123,
Task_ID = 123
});
context.Users = users;
var task = new ProjectManager.Models.Task()
{
Task_Name = "ASDQW",
Parent_ID = 123674,
Project_ID = 34856,
Start_Date = DateTime.Now,
End_Date = DateTime.Now.AddDays(2),
Priority = 10,
Status = 0,
User = new User()
{
FirstName = "Sweta",
LastName = "ChowdMisrahury",
EmployeeId = "123456",
UserId = 123
}
};
var controller = new TaskController(new BC.TaskBC(context));
var result = controller.InsertTaskDetails(task) as JSendResponse;
addCounter.Increment();
}
public void SeedExtensions_AddSecondaryObjects_DbSet_Empty()
{
// This test verifies that items were seeded into the DB set when the DB set is initially empty
var modelDbSetPrimary = new TestDbSet <PrimaryObject>();
var modelDbSetSecondary = new TestDbSet <SecondaryObject>();
var source = new List <SecondaryObject>();
modelDbSetPrimary.AddRange(new[]
{
new PrimaryObject(Guid.NewGuid()),
new PrimaryObject(Guid.NewGuid()),
new PrimaryObject(Guid.NewGuid()),
new PrimaryObject(Guid.NewGuid()),
});
modelDbSetSecondary.AddRange(source);
_context.Setup(_ => _.Set <PrimaryObject>()).Returns(modelDbSetPrimary);
_context.Setup(_ => _.Set <SecondaryObject>()).Returns(modelDbSetSecondary);
_context.Object.AddSecondaryObjects();
var destination = modelDbSetSecondary.ToList();
Assert.IsNotNull(destination);
Assert.AreNotEqual(source.Count, destination.Count);
}
public async Task TestToPagedQueryResultsExtension()
{
var list = new TestDbSet <PagedQueryResultsTestClass>();
for (var i = 0; i < 10; i++)
{
list.Add(new PagedQueryResultsTestClass
{
Id = i
});
}
var start = 0;
var limit = 1;
Action <PagedQueryResults <PagedQueryResultsTestClass> > tester = (results) =>
{
Assert.AreEqual(list.Count(), results.Total);
Assert.AreEqual(limit, results.Results.Count);
};
var queryable = list.AsQueryable();
var pagedResults = queryable.ToPagedQueryResults(start, limit);
var pagedResultsAsync = await queryable.ToPagedQueryResultsAsync(start, limit);
}
public void TestInsertProjects_Success(BenchmarkContext benchContext)
{
var context = new MockProjectManagerEntities();
var users = new TestDbSet <DAC.User>();
users.Add(new DAC.User()
{
Employee_ID = "414948",
First_Name = "Sweta",
Last_Name = "Misra",
User_ID = 123,
Task_ID = 123
});
context.Users = users;
var testProject = new ProjectManager.Models.Project()
{
ProjectId = 12345,
ProjectName = "MyProject",
ProjectStartDate = DateTime.Now,
ProjectEndDate = DateTime.Now.AddDays(5),
Priority = 3,
NoOfCompletedTasks = 3,
NoOfTasks = 5,
User = new User()
{
FirstName = "Sweta",
LastName = "Misra",
EmployeeId = "123456",
UserId = 123
}
};
var controller = new ProjectController(new BC.ProjectBC(context));
var result = controller.InsertProjectDetails(testProject) as JSendResponse;
addCounter.Increment();
}
public async void GetRefreshTokenAsync_ShouldReturnRefreshTokenStringFromDatabase()
{
var loggerMock = new Mock <ILogger <AccessTokenService> >();
var optionsMock = new Mock <IOptions <AppSettings> >();
var appSettingsMock = new Mock <AppSettings>();
var contextMock = new Mock <IDatabaseContext>();
optionsMock.Setup(x => x.Value)
.Returns(appSettingsMock.Object);
var refreshToken = GetRefreshTokenSample();
var dbSet = new TestDbSet <RefreshToken>();
dbSet.Add(refreshToken);
contextMock.Setup(x => x.RefreshTokens)
.Returns(dbSet);
var service = new AccessTokenService(loggerMock.Object, contextMock.Object, optionsMock.Object);
var result = await service.GetRefreshTokenAsync(refreshToken.UserId.ToString());
Assert.Equal(result, refreshToken.Token);
}
public TestMysql_serverDbSet()
{
mysql_servers = new TestDbSet <mysql_servers>();
}
public RestierODataContext() : base("name=RestierODataContext")
{
Users = new TestDbSet<User>();
Seed(this);
}
public TestDbContext()
{
Zones = new TestDbSet<Zone>();
ApplianceModels = new TestDbSet<ApplianceModel>();
Appliances = new TestDbSet<Appliance>();
}
public FakeContext()
{
Teachers = new TestDbSet<Teacher>();
Comments = new TestDbSet<Comment>();
Topics = new TestDbSet<Topic>();
}
public TestBlogDbSet(Action <Blog> addCallback, Action <IEnumerable <Blog> > addBulkCallback, Action <Blog> removeCallback, TestDbSet dbSet = null) : base(addCallback, addBulkCallback, removeCallback, dbSet)
{
}
public TestDatabaseModel()
{
PublicationMarks = new TestDbSet<PublicationMark>();
Publications = new TestDbSet<Publication>();
Users = new TestDbSet<User>();
}
public void Execute_ReturnsEmptyIfSearchTermsAreNull()
{
DbSet<Link> testDbSet = new TestDbSet<Link>();
testDbSet.Add(new Link());
IQueryable<Link> results = StringQuery.Execute(testDbSet, new string[] {null});
Assert.IsNotNull(results);
Assert.AreEqual(0, results.Count());
}
public StubbedBookContext(IEnumerable <Book> initialBookList = null, IEnumerable <Author> initialAuthorList = null)
{
Books = new TestDbSet <Book>(initialBookList);
Authors = new TestDbSet <Author>(initialAuthorList);
}
public void TestInitialize()
{
parametersDbSet = new TestDbSet <Parameter>()
{
new Parameter()
{
ParameterId = 0,
ParameterName = "@Name",
ParameterRuName = "Имя",
ParameterType = "text",
ParameterCreatedDate = DateTime.Today.AddDays(-1)
},
new Parameter()
{
ParameterId = 1,
ParameterName = "@Age",
ParameterRuName = "Возраст",
ParameterType = "number",
ParameterCreatedDate = DateTime.Now
},
new Parameter()
{
ParameterId = 2,
ParameterName = "@Position",
ParameterRuName = "Должность",
ParameterType = "text",
ParameterCreatedDate = DateTime.Today.AddDays(-2)
},
new Parameter()
{
ParameterId = 3,
ParameterName = "@Skills",
ParameterRuName = "Навыки",
ParameterType = "text",
ParameterCreatedDate = DateTime.Today.AddDays(-4)
},
new Parameter()
{
ParameterId = 4,
ParameterName = "@Address",
ParameterRuName = "Адрес",
ParameterType = "text",
ParameterCreatedDate = DateTime.Now
},
new Parameter()
{
ParameterId = 5,
ParameterName = "@Phone",
ParameterRuName = "Телефон",
ParameterType = "phone",
ParameterCreatedDate = DateTime.Today.AddDays(-1)
},
new Parameter()
{
ParameterId = 6,
ParameterName = "@Mail",
ParameterRuName = "Почта",
ParameterType = "email",
ParameterCreatedDate = DateTime.Today.AddDays(-2)
}
};
queriesDbSet = new TestDbSet <SqlQuery>()
{
new SqlQuery()
{
SqlQueryId = 0,
SqlQueryName = "SelectEmployeesByAgeAndPosition",
SqlQueryContent = "Select age, position from Employees where age = @Age and position = @Postion",
SqlQueryCreatedDate = DateTime.Today
},
new SqlQuery()
{
SqlQueryId = 1,
SqlQueryName = "SelectEmployeesByContacts",
SqlQueryContent = "Select phone, mail from Employees where phone = @Phone and mail = @Mail",
SqlQueryCreatedDate = DateTime.Today.AddDays(-1)
}
};
queryParametersDbSet = new TestDbSet <SqlQueryParameter>()
{
new SqlQueryParameter()
{
SqlQueryParameterId = 0,
SqlQueryId = 0,
ParameterId = 1
},
new SqlQueryParameter()
{
SqlQueryParameterId = 1,
SqlQueryId = 0,
ParameterId = 2
},
new SqlQueryParameter()
{
SqlQueryParameterId = 2,
SqlQueryId = 1,
ParameterId = 5
},
new SqlQueryParameter()
{
SqlQueryParameterId = 3,
SqlQueryId = 1,
ParameterId = 6
}
};
mock = new Mock <IContext>();
mock
.Setup(p => p.Parameters)
.Returns(parametersDbSet);
mock
.Setup(s => s.SqlQueries)
.Returns(queriesDbSet);
mock
.Setup(q => q.SqlQueryParameters)
.Returns(queryParametersDbSet);
queryRepo = new QueryRepository(mock.Object);
}
public TestContext()
{
mysql_servers = new TestDbSet <mysql_servers>();
schedules = new TestDbSet <schedules>();
}
public void GetQueryParametersByQueryIdMethodTest()
{
// Arrange
TestDbSet <Parameter> parametersDbSet = new TestDbSet <Parameter>()
{
new Parameter()
{
ParameterId = 0,
ParameterName = "@test",
ParameterRuName = "test",
ParameterType = "text",
ParameterCreatedDate = DateTime.Now
},
new Parameter()
{
ParameterId = 1,
ParameterName = "@another_one",
ParameterRuName = "another_one",
ParameterType = "number",
ParameterCreatedDate = DateTime.Now
},
new Parameter()
{
ParameterId = 2,
ParameterName = "@param",
ParameterRuName = "param",
ParameterType = "phone",
ParameterCreatedDate = DateTime.Now
}
};
TestDbSet <SqlQuery> queriesDbSet = new TestDbSet <SqlQuery>()
{
new SqlQuery()
{
SqlQueryId = 0,
SqlQueryName = "First query",
SqlQueryContent = "Select * from test",
SqlQueryCreatedDate = DateTime.Now
}
};
TestDbSet <SqlQueryParameter> queryParametersDbSet = new TestDbSet <SqlQueryParameter>()
{
new SqlQueryParameter()
{
SqlQueryParameterId = 0,
SqlQueryId = 0,
ParameterId = 0
},
new SqlQueryParameter()
{
SqlQueryParameterId = 1,
SqlQueryId = 0,
ParameterId = 1
}
};
var mock = new Mock <IContext>();
mock
.Setup(x => x.Parameters)
.Returns(parametersDbSet);
mock
.Setup(x => x.SqlQueries)
.Returns(queriesDbSet);
mock
.Setup(x => x.SqlQueryParameters)
.Returns(queryParametersDbSet);
ParameterRepository repository = new ParameterRepository(mock.Object);
// Act
IEnumerable <Parameter> parameters = repository.GetQueryParametersByQueryId(0);
// Assert
Assert.AreEqual(2, parameters.Count());
Assert.IsTrue(
queryParametersDbSet
.Select(i => i.ParameterId)
.Contains(parameters.First().ParameterId)
);
Assert.IsTrue(
queryParametersDbSet
.Select(i => i.ParameterId)
.Contains(parameters.Last().ParameterId)
);
}
public TestInvoiceHeaderDao(TestDbSet<InvoiceHeader> testDbSet)
{
_testDbSet = testDbSet;
}
public void Execute_IgnoresCase()
{
DbSet<Link> testDbSet = new TestDbSet<Link>();
var linkToFind = new Link {Name = "FOO"};
testDbSet.Add(linkToFind);
var otherLink = new Link {Name = "BAR"};
testDbSet.Add(otherLink);
IQueryable<Link> results = StringQuery.Execute(testDbSet, new[] {"foo"});
Assert.AreEqual(1, results.Count());
Assert.AreEqual(linkToFind, results.First());
}
public void GetInvoiceHeaderByInvoiceId()
{
var testDbSet = new TestDbSet<InvoiceHeader>(_dataCollection);
var testInvoiceHeaderDao = new TestInvoiceHeaderDao(testDbSet);
var invoiceHeader = testInvoiceHeaderDao.GetByInvoiceId(2);
Assert.IsFalse(invoiceHeader == null);
}
public DbLaundryTest()
{
Shirts = new TestDbSet <Shirt>();
Services = new TestDbSet <Service>();
Rates = new TestDbSet <Rates>();
Transactions = new TestDbSet <Transaction>();
TransactionDetails = new TestDbSet <TransactionDetail>();
#region generate dummy data Shirts
Shirts.Add(new Shirt()
{
Id = 1, Name = "T-Shirt"
});
Shirts.Add(new Shirt()
{
Id = 2, Name = "Jeans"
});
Shirts.Add(new Shirt()
{
Id = 3, Name = "Jacket"
});
#endregion
#region generate dummy data Services
Services.Add(new Service()
{
Id = 1, Name = "Wash"
});
Services.Add(new Service()
{
Id = 2, Name = "Dry"
});
Services.Add(new Service()
{
Id = 3, Name = "Rinse"
});
#endregion
#region genereate dummy data Rates
Rates.Add(new Rates()
{
Id = 1, ShirtId = 1, ServiceId = 1, Price = 2000, Unit = "Kg"
});
Rates.Add(new Rates()
{
Id = 2, ShirtId = 1, ServiceId = 2, Price = 2500, Unit = "Kg"
});
Rates.Add(new Rates()
{
Id = 3, ShirtId = 1, ServiceId = 3, Price = 3000, Unit = "Kg"
});
#endregion
#region generate dummy data Transaction
Transactions.Add(new Transaction()
{
Id = 1,
Name = "Ucok",
Address = "Jalan Bakpau",
Phone = "012345678",
TransactionDetails = new Collection <TransactionDetail>()
{
new TransactionDetail()
{
RatesId = 1,
TransactionId = 1,
Quantity = 2
},
new TransactionDetail()
{
RatesId = 2,
TransactionId = 1,
Quantity = 1
}
}
});
Transactions.Add(new Transaction()
{
Id = 2,
Name = "Burhan",
Address = "Jalan Tak Ada Harapan",
Phone = "0696969",
TransactionDetails = new Collection <TransactionDetail>()
{
new TransactionDetail()
{
RatesId = 1,
TransactionId = 2,
Quantity = 3
},
new TransactionDetail()
{
RatesId = 3,
TransactionId = 2,
Quantity = 2
}
}
});
Transactions.Add(new Transaction()
{
Id = 3,
Name = "Goku",
Address = "Planet Namek",
Phone = "88888888",
TransactionDetails = new Collection <TransactionDetail>()
{
new TransactionDetail()
{
RatesId = 2,
TransactionId = 3,
Quantity = 4
},
new TransactionDetail()
{
RatesId = 3,
TransactionId = 3,
Quantity = 3
}
}
});
#endregion
}
public void TestSetup()
{
context = new TestDbSet <Supplier>();
supplierController = new SupplierController(context);
}
private static DbSet<Link> GetTaggableDbSet(params string[] tagStrings)
{
DbSet<Link> testDbSet = new TestDbSet<Link>();
foreach (string tagString in tagStrings)
{
testDbSet.Add(new Link {TagString = tagString});
}
return testDbSet;
}
