public void Test_ScheduleCourse_ProfessorIsTeachingCourseAtSameTime()
{
MockDatabase <CourseSchedule> mockDB = new MockDatabase <CourseSchedule>(c => c.CourseSchedules);
RegistrationData data = new RegistrationData(mockDB.Context);
CourseSchedule existingCourseSchedule = new CourseSchedule
{
Schedule = new Schedule {
StartTime = new TimeSpan(8, 0, 0), TimeBlocks = 2
}
};
Person professor = new Person {
PersonId = 5, CourseSchedules = new List <CourseSchedule> {
existingCourseSchedule
}
};
Schedule schedule = new Schedule {
StartTime = new TimeSpan(9, 30, 0), TimeBlocks = 1
};
Course course = new Course
{
CourseSchedules = new List <CourseSchedule>
{
existingCourseSchedule
}
};
data.ScheduleCourse(course, schedule, professor, 3);
mockDB.MockSet.Verify(m => m.Add(It.IsAny <CourseSchedule>()), Times.Never());
mockDB.MockContext.Verify(m => m.SaveChanges(), Times.Never());
}
public void Initialize()
{
var mockDb = new MockDatabase();
InitMockData.InitData(mockDb);
_file = new FileRepository(mockDb);
}
public void Test_ModifyCourse()
{
MockDatabase <CourseSchedule> mockDB = new MockDatabase <CourseSchedule>(c => c.CourseSchedules);
RegistrationData data = new RegistrationData(mockDB.Context);
CourseSchedule existingCourseSchedule = new CourseSchedule
{
Schedule = new Schedule {
StartTime = new TimeSpan(8, 0, 0), TimeBlocks = 2
},
Capacity = 15
};
mockDB.AddDataEntry(existingCourseSchedule);
Schedule schedule = new Schedule {
StartTime = new TimeSpan(11, 0, 0), TimeBlocks = 1
};
short capacity = 30;
data.ModifyCourse(existingCourseSchedule, schedule, capacity);
Assert.Equal(schedule.StartTime, existingCourseSchedule.Schedule.StartTime);
Assert.Equal(schedule.TimeBlocks, existingCourseSchedule.Schedule.TimeBlocks);
Assert.Equal(capacity, existingCourseSchedule.Capacity);
mockDB.MockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public void Test_GetNumberOfStudentsInCourse()
{
MockDatabase <CourseSchedule> mockDB = new MockDatabase <CourseSchedule>(c => c.CourseSchedules);
RegistrationData data = new RegistrationData(mockDB.Context);
CourseSchedule schedule = new CourseSchedule
{
Capacity = 3,
StudentSchedules = new List <StudentSchedule>
{
new StudentSchedule {
Enrolled = true
},
new StudentSchedule {
Enrolled = false
},
new StudentSchedule {
Enrolled = true
}
}
};
mockDB.AddDataEntry(schedule);
int expected = 2;
int actual = data.GetNumberOfStudentsInCourse(schedule);
Assert.Equal(expected, actual);
}
/// <summary>
/// 认证
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
await Task.Run(() => {
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
//查询数据库进行信息验证clientid省略
UsersEntity user = MockDatabase.CheckUser(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The username or password is incorrect");
return;
}
//基于声明的认证，用来标识一个人的身份（如：姓名，邮箱等等），access_token中保存的信息
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.Name, user.UserName));
identity.AddClaim(new Claim(ClaimTypes.Role, "user"));
identity.AddClaim(new Claim("TokenID", Guid.NewGuid().ToString("n")));
identity.AddClaim(new Claim("UserId", user.UserID));
identity.AddClaim(new Claim("Email", user.Email));
//认证信息，可以说成证书信息
var props = new AuthenticationProperties(new Dictionary <string, string>
{
{ "UserName", user.UserName },
});
var ticket = new AuthenticationTicket(identity, props);
context.Validated(ticket);
});
}
public void CheckMockWorking()
{
var mockDatabase = new MockDatabase();
var db = CreateDatabase(mockDatabase);
Assert.NotNull(db);
}
private async Task Initialize()
{
var variacionDivisas = await MockDatabase.ObtenerVariacionDivisas();
var serie = new CandleStickSeries()
{
Color = OxyColor.Parse(Colors[0]),
StrokeThickness = 2,
LineStyle = LineStyle.Solid,
DataFieldClose = "Cierre",
DataFieldHigh = "Maximo",
DataFieldLow = "Minimo",
DataFieldOpen = "Apertura",
DataFieldX = "Hora",
ItemsSource = variacionDivisas,
Title = "Variación del peso frente al dólar"
};
ChartModel.Series.Add(serie);
ChartModel.Axes.Add(new LinearAxis {
Position = AxisPosition.Bottom, Title = "Hora del día"
});
ChartModel.Axes.Add(new LinearAxis {
Position = AxisPosition.Left, Title = "Valor [$]"
});
}
public void Initialize()
{
var mockDb = new MockDatabase();
#region Notifications
var n1 = new Notification()
{
NotificationId = 1,
FriendUserId = "2",
UserId = "1",
Date = new DateTime(2000, 1, 1)
};
mockDb.Notifications.Add(n1);
var n2 = new Notification()
{
NotificationId = 2,
FriendUserId = "2",
UserId = "4",
Date = new DateTime(2001, 1, 1)
};
mockDb.Notifications.Add(n2);
var n3 = new Notification()
{
NotificationId = 3,
FriendUserId = "3",
UserId = "1",
Date = new DateTime(2002, 1, 1)
};
mockDb.Notifications.Add(n3);
#endregion
service = new NotificationService(mockDb);
}
public void ThenUserHasNoAssignedActiveDirectoryAccount(string userName)
{
Guid userId = MockDatabase.GetUser(userName).Id;
IEnumerable <IAccount> accounts = IdentityManagementService.GetUserAccounts(userId);
Assert.IsFalse(accounts.Any(o => o.Type == AccountType.Federated));
}
public void Initialize()
{
var mockDb = new MockDatabase();
InitMockData.InitData(mockDb);
_folder = new FolderRepository(mockDb);
}
public void WhenTheUserIsRemovedFromTheOrganization(string user, string organization)
{
Guid organizationId = MockDatabase.GetOrganization(organization).Id;
Guid userId = nameIdentifierPairs[user];
Try(() => IdentityManagementService.RemoveUserOrganization(userId, organizationId));
}
public void Initialize()
{
var mockDb = new MockDatabase();
InitMockData.InitData(mockDb);
_Project = new ProjectsRepository(mockDb);
}
private static void SetupMockDatabase(ContainerBuilder builder)
{
var dbContext = new MockDbContext();
builder.RegisterInstance(dbContext).As<IDbContext>();
var database = new MockDatabase(dbContext);
ScenarioContext.Current.Set(database);
}
public void ThenUserHasAFederatedAccountWithName(string userName, string accountName)
{
Guid userId = MockDatabase.GetUser(userName).Id;
IEnumerable <IAccount> accounts = IdentityManagementService.GetUserAccounts(userId);
Assert.AreEqual(1, accounts.Count(a => a.Type == AccountType.Federated && a.Name == accountName));
}
public void Initialize()
{
var MockDb = new MockDatabase();
var P1 = new Project
{
ID = 4,
Name = "Project1"
};
MockDb.Projects.Add(P1);
var P2 = new Project
{
ID = 2,
Name = "Project2"
};
MockDb.Projects.Add(P2);
var F1 = new Folder
{
ID = 1,
Name = "1Root",
FolderStructure = null,
ProjectStructure = P1
};
MockDb.Folders.Add(F1);
var F2 = new Folder
{
ID = 2,
Name = "11Child",
FolderStructure = F1,
ProjectStructure = P1
};
MockDb.Folders.Add(F2);
var F3 = new Folder
{
ID = 3,
Name = "12Child",
FolderStructure = F1,
//ProjectStructure = P1
};
MockDb.Folders.Add(F3);
var F4 = new Folder
{
ID = 4,
Name = "111Grandchild",
FolderStructure = F2,
//ProjectStructure = P1
};
MockDb.Folders.Add(F4);
service = new FolderService(MockDb);
}
public void ConfigInject_MockDatabaseIsInitializedWithTwoParameters()
{
MockDatabase db = ResolveConfiguredObject <MockDatabase>("stringIntConstructor");
Assert.IsFalse(db.DefaultConstructorCalled);
Assert.AreEqual("Northwind", db.ConnectionString);
Assert.AreEqual(101, db.SomeNumber);
}
public void Index_SelectTestEntity_ReturnTestEntityMockTable()
{
MockDatabase database = new MockDatabase();
database.Add(new TestEntity(42));
MockTable <IEntity> testEntities =
database[typeof(TestEntity)];
}
public void InitizlizerPerson_Success()
{
MockDatabase database = new MockDatabase();
Person person = database.Person;
Assert.IsNotNull(person);
Assert.AreEqual <Person>(person, database.Person);
}
public void TestFindGreaterThanWithInt32()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.foo.Users.Find(database.foo.Users.Id > 1);
Assert.AreEqual("select " + usersColumns + " from [foo].[Users] where [foo].[Users].[Id] > @p1".ToLowerInvariant().ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(1, mockDatabase.Parameters[0]);
}
public void TestFindAllByDynamic()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.foo.Users.FindAllByName("Foo").ToList();
Assert.AreEqual("select [foo].[Users].[Id],[foo].[Users].[Name],[foo].[Users].[Password],[foo].[Users].[Age] from [foo].[Users] where [foo].[Users].[name] = @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual("Foo", mockDatabase.Parameters[0]);
}
public async Task CanParseInput(string input, decimal multiplier, decimal offset)
{
IDatabaseAccess db = new MockDatabase();
var unitFactory = new UnitFactory(db);
var unit = await unitFactory.Parse(input);
unit.Multiplier.Should().Be(multiplier);
unit.OffSet.Should().Be(offset);
}
public void TestFindWithDotInSchemaName()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.foobar.Test.Find(database.foobar.Test.Id == 1);
Assert.AreEqual("select [foo.bar].[Test].[Id], [foo.bar].[Test].[Value] from [foo.bar].[Test] where [foo.bar].[Test].[id] = @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(1, mockDatabase.Parameters[0]);
}
public void TestDeleteWithNamedArguments()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.Users.Delete(Id: 1);
Assert.AreEqual("delete from [dbo].[Users] where [dbo].[Users].[Id] = @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(1, mockDatabase.Parameters[0]);
}
public void TestFindAllWithLike()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.Users.FindAll(database.Users.Name.Like("Foo")).ToList();
Assert.AreEqual("select [dbo].[Users].* from [dbo].[Users] where [dbo].[Users].[name] like @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual("Foo", mockDatabase.Parameters[0]);
}
public void TestThatUpdateUsesDbNullForNullValues()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.Users.UpdateById(Id: 1, Name: null);
Assert.AreEqual("update [dbo].[Users] set [Name] = @p1 where [dbo].[Users].[Id] = @p2".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(DBNull.Value, mockDatabase.Parameters[0]);
}
public void TestFindNotEqualWithInt32()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.Users.Find(database.Users.Id != 1);
Assert.AreEqual("select [dbo].[Users].* from [dbo].[Users] where [dbo].[Users].[Id] != @p1".ToLowerInvariant().ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(1, mockDatabase.Parameters[0]);
}
public void ConfiguringNamedInjectionDoesntAffectDefault()
{
IUnityContainer container = GetConfiguredContainer("injectNamed");
MockDatabase defaultDb = container.Resolve <MockDatabase>();
MockDatabase nwDb = container.Resolve <MockDatabase>("Northwind");
Assert.AreEqual("contoso", defaultDb.ConnectionString);
Assert.AreEqual("Northwind", nwDb.ConnectionString);
}
public void TestFindByDynamicSingleColumn()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.foo.Users.FindByName("Foo");
Assert.AreEqual("select [foo].[Users].* from [foo].[Users] where [foo].[Users].[name] = @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual("Foo", mockDatabase.Parameters[0]);
}
public void TestFindLessThanOrEqualWithInt32()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.foo.Users.Find(database.foo.Users.Id <= 1);
Assert.AreEqual("select [foo].[Users].* from [foo].[Users] where [foo].[Users].[Id] <= @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(1, mockDatabase.Parameters[0]);
}
public void TestDeleteBy()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
database.foo.Users.DeleteById(1);
Assert.AreEqual("delete from [foo].[Users] where [foo].[Users].[Id] = @p1".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual(1, mockDatabase.Parameters[0]);
}
public IActionResult Index(int id = 10000)
{
MockDatabase database = new MockDatabase();
PatientName = database.GetPatient(id).ToString();
var reminders = database.RetrieveAllReminders(id);
return(View(reminders));
}
public void SetUpContext()
{
db = new MockDatabase();
SocialContext = new MockSocialContext
{
Users = { db.user0, db.user1, db.user2, db.user3, db.user4 },
Groups = { db.group0, db.group1, db.group2, db.group3 },
Locations = { db.location0, db.location1, db.location2 },
Posts = { db.post0, db.post1, db.post2, db.post3, db.post4 }
};
}
public void SetUp()
{
MockWikiApplication application = new MockWikiApplication(new FederationConfiguration(),
new LinkMaker("test://SqlStoreTests/"), OutputFormat.HTML,
new MockTimeProvider(TimeSpan.FromSeconds(1)));
_federation = new Federation(application);
_database = new MockDatabase(TestDataSets.Default());
_federation.RegisterNamespace(new SqlStore(_database), "NamespaceOne",
new NamespaceProviderParameterCollection(
new NamespaceProviderParameter("ConnectionString", _connectionString)));
// Necessary to bypass security because a non-existent manager can't be
// retrieved directly from the federation
NamespaceManager manager = WikiTestUtilities.GetNamespaceManagerBypassingSecurity(_federation, "NamespaceOne");
_provider = (SqlStore)manager.GetProvider(typeof(SqlStore));
}
