public void IsManagerApprovalTaskNotComplete()
{
SPListItem item = CreateMockSPListItem(SPListItemMockType.StatusCheck, "Pending");
bool isComplete = Controller.IsManagerApprovalTaskComplete(item);
Assert.IsFalse(isComplete);
MockManager.Verify();
}
public void IsManagerApprovalTaskCompleteRejected()
{
SPListItem item = CreateMockSPListItem(SPListItemMockType.StatusCheck, "Rejected");
bool isComplete = Controller.IsManagerApprovalTaskComplete(item);
Assert.IsTrue(isComplete);
MockManager.Verify();
}
public void Delete_IdIsValid_ItemDeleted()
{
SPWeb web = this.RecordWebForDelete();
ListItemRepository listItemRepository = new ListItemRepository();
SPQuery query = new SPQuery();
listItemRepository.Delete(web, "Registrations", 1);
MockManager.Verify();
}
public void GenerateCodeForSmartPartInfoCompiles()
{
DesignerSerializerAttribute attr = (DesignerSerializerAttribute)Attribute.GetCustomAttribute(
typeof(SmartPartInfo), typeof(DesignerSerializerAttribute));
CodeDomSerializer serializer = (CodeDomSerializer)Activator.CreateInstance(Type.GetType(attr.SerializerTypeName));
UserControl smartPart = new UserControl();
Container container = new Container();
SmartPartInfo info1 = new SmartPartInfo("foo", "");
container.Add(info1, "info1");
MockSPI info2 = new MockSPI("bar", "");
container.Add(info2, "info2");
MockManager manager = new MockManager(container.Components);
manager.Services.Add(typeof(IDesignerHost), new MockDesignerHost(smartPart, container));
manager.Services.Add(typeof(IReferenceService), new MockReferenceService(container.Components));
manager.Services.Add(typeof(IContainer), container);
manager.Services.Add(typeof(IDesignerSerializationManager), manager);
CodeTypeDeclaration declaration = new CodeTypeDeclaration("UserControl1");
CodeMemberMethod init = new CodeMemberMethod();
init.Name = "InitializeComponent";
declaration.Members.Add(init);
// Add empty fields for both SPIs.
declaration.Members.Add(new CodeMemberField(typeof(ISmartPartInfo), "info1"));
declaration.Members.Add(new CodeMemberField(typeof(ISmartPartInfo), "info2"));
manager.Services.Add(typeof(CodeTypeDeclaration), declaration);
serializer.Serialize(manager, info1);
serializer.Serialize(manager, info2);
StringWriter sw = new StringWriter();
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromType(
declaration, sw, new CodeGeneratorOptions());
sw.Flush();
//Console.WriteLine(sw.ToString());
CompilerResults results = new Microsoft.CSharp.CSharpCodeProvider().CompileAssemblyFromSource(
new CompilerParameters(new string[] {
"System.dll",
new Uri(typeof(SmartPartInfo).Assembly.CodeBase).LocalPath
}),
sw.ToString());
Assert.IsFalse(results.Errors.HasErrors, ErrorsToString(results.Errors));
}
public void Get_QueryIsValid_ItemFound()
{
SPWeb web = this.RecordWebForGet();
ListItemRepository listItemRepository = new ListItemRepository();
SPQuery query = new SPQuery();
SPListItem item = null;
item = listItemRepository.Get(web, "Registrations", query);
Assert.IsNotNull(item);
MockManager.Verify();
}
public void CanDelete()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationRepository repository = new RegistrationRepository();
repository.Delete(1, web);
Assert.IsTrue(MockListItemRepository.CalledUpdateOrDelete);
MockManager.Verify();
}
public void RenderCourseRegistrationPopulatesViewWithCourseSelectionList()
{
string loginName = @"domain\alias";
SPWeb mockWeb = this.CreateMockSPWeb(true);
MockCourseRegistrationView mockView = new MockCourseRegistrationView();
mockView.QueryString = new System.Collections.Specialized.NameValueCollection();
TrainingCourse course = new TrainingCourse()
{
Id = 1,
Code = "TestCode"
};
MockTrainingCourseRepository.TrainingCourseReturnedByGet = course;
List <TrainingCourse> courses = new List <TrainingCourse>();
TrainingCourse course1 = new TrainingCourse()
{
Id = 1,
Code = "TstCode1"
};
TrainingCourse course2 = new TrainingCourse()
{
Id = 2,
Code = "TstCode2"
};
courses.Add(course1);
courses.Add(course2);
MockTrainingCourseRepository.TrainingCourseListReturnedByGet = courses;
this.serviceLocator.Register <IRegistrationRepository>(typeof(MockRegistrationRepository));
this.serviceLocator.Register <ITrainingCourseRepository>(typeof(MockTrainingCourseRepository));
CourseRegistrationPresenter presenter = new CourseRegistrationPresenter(mockView);
presenter.RenderCourseRegistrationView(mockWeb, loginName);
Assert.AreEqual <string>("Course Registration", mockView.HeaderTitle);
Assert.AreEqual <string>("Course Registration - New", mockView.PageTitle);
Assert.AreEqual <string>("New", mockView.HeaderSubtitle);
Assert.AreEqual <string>("Which course would you like to register for?", mockView.ContentMessage);
Assert.IsNotNull(mockView.Courses);
Assert.AreEqual(2, mockView.Courses.Count);
Assert.AreEqual("TstCode1", mockView.Courses[0].Code);
Assert.AreEqual("TstCode2", mockView.Courses[1].Code);
Assert.IsTrue(mockView.ShowConfirmationControls);
Assert.IsTrue(mockView.ShowCourseSelectionControls);
Assert.AreEqual("http://localhost/training", mockView.SiteLink);
MockManager.Verify();
}
public void Update_IdAndItemIsValid_ItemUpdated()
{
SPWeb web = this.RecordWebForUpdate();
ListItemRepository listItemRepository = new ListItemRepository();
Dictionary <Guid, object> fields = new Dictionary <Guid, object>();
fields.Add(new Guid(Fields.CourseId), 1);
fields.Add(new Guid(Fields.UserId), 1);
listItemRepository.Update(web, "Registrations", 1, fields);
MockManager.Verify();
}
public void Get_ValidListName_ItemsFound()
{
SPWeb web = this.RecordWebForGetAll();
ListItemRepository listItemRepository = new ListItemRepository();
SPQuery query = new SPQuery();
SPListItemCollection items = null;
items = listItemRepository.Get(web, "Registrations");
Assert.IsNotNull(items);
Assert.AreEqual(2, items.Count);
MockManager.Verify();
}
public void Photo_Comment()
{
MockManager.Init();
#region Add comment
Mock photoCommentAdd = MockManager.Mock <CommentRepository>(Constructor.NotMocked);
photoCommentAdd.ExpectAndReturn("Authenticate", "1234").Args(Permission.Delete.ToString());
photoCommentAdd.ExpectAndReturn("GetSignature", "yyyy");
photoCommentAdd.ExpectAndReturn("DoHTTPPost", MockElement(RESOURCE_NS + ".AddComment.xml").ToString());
Comment comment = new Comment();
comment.PhotoId = COMMENT_PHOTO_ID;
comment.Text = "Testing comment add [LINQ.Flickr]";
_context.Photos.Comments.Add(comment);
_context.SubmitChanges();
Assert.IsTrue(comment.Id == "1");
#endregion
#region Get added comment
Mock photoCommentMock = MockManager.Mock <CommentRepository>(Constructor.NotMocked);
Mock httpCallBase = MockManager.Mock <RestToCollectionBuilder <Comment> >(Constructor.NotMocked);
photoCommentMock.ExpectAndReturn("GetSignature", "yyyy");
httpCallBase.ExpectAndReturn("GetElement", MockElement(RESOURCE_NS + ".GetComment.xml"));
var query = from c in _context.Photos.Comments
where c.PhotoId == COMMENT_PHOTO_ID && c.Id == comment.Id
select c;
Comment commentGet = query.Single();
Assert.IsTrue(commentGet.Author == "11" && commentGet.PhotoId == COMMENT_PHOTO_ID && commentGet.AuthorName == "John Doe");
#endregion
#region Delete added
Mock photoCommentDelete = MockManager.Mock <CommentRepository>(Constructor.NotMocked);
photoCommentDelete.ExpectAndReturn("Authenticate", "1234").Args(Permission.Delete.ToString());
photoCommentDelete.ExpectAndReturn("GetSignature", "yyyy");
photoCommentDelete.ExpectAndReturn("DoHTTPPost", MockElement(RESOURCE_NS + ".DeleteComment.xml").ToString());
_context.Photos.Comments.Remove(comment);
_context.SubmitChanges();
#endregion
MockManager.Verify();
}
public async Task DeleteMessageShouldReturnFalseIfMessageDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var messageService = new MessageService(db);
// Act
var result = await messageService.DeleteMessageAsync(1);
// Assert
result
.Should()
.Be(false);
}
public async Task DeleteAccountShouldReturnFalseIfUserDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var userService = new UserService(db);
// Act
var result = await userService.DeleteAccountAsync("unexistingUser");
// Assert
result
.Should()
.Be(false);
}
public async Task AlbumOwnerIdShouldReturnNullIfAlbumDoesNotExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var pictureService = new PictureService(db);
// Act
var result = await pictureService.AlbumOwnerId(1);
// Assert
result
.Should()
.BeNull();
}
public void Add_ItemIsValid_ItemAdded()
{
SPWeb web = this.RecordWebForAdd();
ListItemRepository listItemRepository = new ListItemRepository();
Dictionary <Guid, object> fields = new Dictionary <Guid, object>();
fields.Add(new Guid(Fields.CourseId), 1);
fields.Add(new Guid(Fields.UserId), 1);
SPListItem newItem = null;
newItem = listItemRepository.Add(web, "Registrations", fields);
Assert.IsNotNull(newItem);
MockManager.Verify();
}
public async Task AcceptFriendshipShouldReturnTrueIfBothUsersExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "Blq",
LastName = "Qlb"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var friendship = new Friendship
{
User = firstUser,
Friend = secondUser,
FriendshipIssuerId = firstUser.Id
};
await db.Friendships.AddAsync(friendship);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.AcceptFriendshipAsync(firstUser.UserName, secondUser.UserName);
// Assert
result
.Should()
.Be(true);
}
public void ChargeAccounting()
{
Registration registration = new Registration()
{
Id = 1,
Title = "TestTitle",
CourseId = 1,
UserId = 1,
RegistrationStatus = "Pending"
};
MockRegistrationRepository.RegistrationReturnedByGet = registration;
MockTrainingCourseRepository mockTrainingCourseRepository = new MockTrainingCourseRepository();
TrainingCourse trainingCourse = new TrainingCourse()
{
Id = 1,
Title = "TestTitle",
Description = "TestDescription",
Code = "TestCode",
Cost = 123f,
EnrollmentDate = DateTime.Today,
StartDate = DateTime.Today.AddDays(1),
EndDate = DateTime.Today.AddDays(2)
};
MockTrainingCourseRepository.TrainingCourseReturnedByGet = trainingCourse;
serviceLocator.Register <IRegistrationRepository>(typeof(MockRegistrationRepository));
serviceLocator.Register <ITrainingCourseRepository>(typeof(MockTrainingCourseRepository));
serviceLocator.Register <IHRManager>(typeof(MockHRManager));
serviceLocator.Register <IAccountingManager>(typeof(MockAccountingManager));
SPWeb web = CreateMockSPWeb(SPWebMockType.UserOnly);
SPListItem item = CreateMockSPListItem(SPListItemMockType.Populate, string.Empty);
Controller controller = new Controller();
controller.ChargeAccounting(web, item);
Transaction savedTransaction = MockAccountingManager.savedTransaction;
Assert.AreEqual(123f, savedTransaction.Amount);
Assert.AreEqual("DEP100", savedTransaction.CostCenter);
Assert.AreEqual("Training", savedTransaction.Bucket);
Assert.AreEqual(string.Format("{0} training course registration by {1}.", "TestTitle", "TestUser"), savedTransaction.Description);
MockManager.Verify();
}
public SPSXsltExtension_Test()
{
SPSKeyValueList list = new SPSKeyValueList();
list.Add("key0", "value0");
list.Add("key1", "value1");
list.Add("key2", "value2");
Mock <Page> mockPage = MockManager.MockObject <Page>(Constructor.Mocked);
Mock <Control> mockControl = MockManager.MockObject <Control>(Constructor.Mocked);
mockControl.MockedInstance.ID = "TestID";
_extension = new SPSXsltExtension(mockControl.MockedInstance, mockPage.MockedInstance, list);
MockManager.Verify();
}
public void CanUpdate()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
RegistrationApprovalTask registrationApprovalTask = new RegistrationApprovalTask();
registrationApprovalTask.Id = 1;
registrationApprovalTask.Title = "TestTitle";
registrationApprovalTask.WorkflowItemId = 5;
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationApprovalTaskRepository registrationApprovalTaskRepository = new RegistrationApprovalTaskRepository();
registrationApprovalTaskRepository.Update(registrationApprovalTask, web);
Assert.IsTrue(MockListItemRepository.CalledUpdateOrDelete);
MockManager.Verify();
}
public void GetResponseRedirectsExceededTest()
{
HttpWebServiceRequest request = new HttpWebServiceRequest(_webServiceState);
Mock <HttpWebResponse> webResponse = MockManager.MockAll <HttpWebResponse>(Constructor.NotMocked);
webResponse.ExpectGetAlways("StatusCode", HttpStatusCode.Redirect);
webResponse.ExpectAndReturn("GetResponseHeader", _url, _webServiceState.MaxRedirects + 1);
try
{
request.GetResponse(_url, _responseStream, _accept);
Assert.Fail("No exception thrown");
}
catch (HttpWebServiceException ex)
{
Assert.AreEqual(HttpWebServiceExceptionStatus.RedirectsExceeded, ex.Status, "Incorrect exception type");
}
}
public void CanAdd()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
SPListItem item = this.RecordAddSPListItem();
RegistrationApprovalTask registrationApprovalTask = new RegistrationApprovalTask();
registrationApprovalTask.Title = "TestTitle";
registrationApprovalTask.WorkflowItemId = 5;
MockListItemRepository.SPListItemReturnedByGet = item;
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationApprovalTaskRepository registrationApprovalTaskRepository = new RegistrationApprovalTaskRepository();
int id = registrationApprovalTaskRepository.Add(registrationApprovalTask, web);
Assert.AreEqual(1, id);
MockManager.Verify();
}
public void NoDirectReportsFoundNullWeb()
{
serviceLocator.Register <IHRManager>(typeof(MockHRManager));
//Web not being set here
this.mockView.LoginName = string.Format(@"{0}\{1}", Environment.MachineName, "spgmanager");
this.mockView.ShowLogin = false;
DirectReportsPresenter presenter = new DirectReportsPresenter(this.mockView);
presenter.SetDirectReportsSource("http://localhost/training/manage.aspx");
//assert error message
Assert.IsNull(this.mockView.DirectReports);
Assert.AreEqual("An unexpected error occurred.", this.mockView.DirectReportsMessage);
MockManager.Verify();
}
public SPSXsltExtension_Test()
{
SPSKeyValueList list = new SPSKeyValueList();
list.Add("key0", "value0");
list.Add("key1", "value1");
list.Add("key2", "value2");
Mock <Page> mockPage = MockManager.MockObject <Page>(Constructor.Mocked);
SPSXsltCommandControl xsltCommandControl = new SPSXsltCommandControl
{
ID = "TestID"
};
_extension = new SPSXsltExtension(xsltCommandControl, mockPage.MockedInstance, list);
MockManager.Verify();
}
public void CanGetById()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
SPListItem item = this.RecordGetReturnSPListItem();
RegistrationApprovalTask registrationApprovalTask = new RegistrationApprovalTask();
MockListItemRepository.SPListItemReturnedByGet = item;
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationApprovalTaskRepository registrationApprovalTaskRepository = new RegistrationApprovalTaskRepository();
registrationApprovalTask = registrationApprovalTaskRepository.Get(1, web);
Assert.IsNotNull(registrationApprovalTask);
Assert.AreEqual <int>(1, registrationApprovalTask.Id);
Assert.AreEqual <string>("TestTitle", registrationApprovalTask.Title);
Assert.AreEqual <int>(5, registrationApprovalTask.WorkflowItemId);
MockManager.Verify();
}
public void CanUpdate()
{
SPWeb web = this.RecordUpdateReturnSPWeb();
Registration registration = new Registration();
registration.Id = 1;
registration.Title = "UnitTest";
registration.CourseId = 1234;
registration.UserId = 100;
registration.RegistrationStatus = "Pending";
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationRepository repository = new RegistrationRepository();
repository.Update(registration, web);
Assert.IsTrue(MockListItemRepository.CalledUpdateOrDelete);
MockManager.Verify();
}
public void Init()
{
_context = Isolate.Fake.Instance <ActionExecutingContext>();
_result = Isolate.Fake.Instance <ActionExecutedContext>();
_session = Isolate.Fake.Instance <ISession>();
_transaction = Isolate.Fake.Instance <ITransaction>();
Isolate.WhenCalled(() => _session.Transaction).WillReturn(_transaction);
Isolate.WhenCalled(() => _transaction.IsActive).WillReturn(true);
_mock = MockManager.Mock <TransactionAttribute>();
_mock.CallBase.ExpectCall("OnActionExecuted");
_attr = new TransactionAttribute();
Isolate.NonPublic.Property.WhenGetCalled(_attr, "Session").WillReturn(_session);
_loginController = ObjectFactory.GetInstance <LoginController>();
_homeController = ObjectFactory.GetInstance <HomeController>();
}
public void PopulateManagerApprovalTask()
{
Registration registration = new Registration()
{
Id = 1,
Title = "TestTitle",
CourseId = 1,
UserId = 1,
RegistrationStatus = "Pending"
};
MockRegistrationRepository.RegistrationReturnedByGet = registration;
TrainingCourse trainingCourse = new TrainingCourse()
{
Id = 1,
Title = "TestTitle",
Description = "TestDescription",
Code = "TestCode",
Cost = 123f,
EnrollmentDate = DateTime.Today,
StartDate = DateTime.Today.AddDays(1),
EndDate = DateTime.Today.AddDays(2)
};
MockTrainingCourseRepository.TrainingCourseReturnedByGet = trainingCourse;
serviceLocator.Register <IRegistrationRepository>(typeof(MockRegistrationRepository));
serviceLocator.Register <ITrainingCourseRepository>(typeof(MockTrainingCourseRepository));
serviceLocator.Register <IHRManager>(typeof(MockHRManager));
SPWorkflowTaskProperties taskProperties = new SPWorkflowTaskProperties();
SPWeb web = CreateMockSPWeb(SPWebMockType.UserAndManager);
SPListItem item = CreateMockSPListItem(SPListItemMockType.Populate, string.Empty);
Controller controller = new Controller();
controller.PopulateManagerApprovalTaskProperties(taskProperties, web, item);
Assert.AreEqual(String.Format(@"{0}\{1}", Environment.MachineName, "spgmanager").ToLower(), taskProperties.AssignedTo.ToLower());
Assert.AreEqual(string.Format("Approve new registration request from {0} for {1}.", "TestUser", "TestCode"), taskProperties.Title);
MockManager.Verify();
}
public async Task CreateMessageShouldReturnTrueIfBothSenderAndReceiverExist()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Chloe"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var messageService = new MessageService(db);
// Act
var result = await messageService.CreateMessageAsync(firstUser.UserName, secondUser.UserName, "Some content");
// Assert
result
.Should()
.Be(true);
var messageExists = await db.Messages.FirstOrDefaultAsync();
messageExists
.Should()
.NotBeNull();
}
public async Task DeleteAccountShouldReturnTrueIfUserExists()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "Blq",
LastName = "Qlb"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.DeleteAccountAsync(firstUser.UserName);
// Assert
result
.Should()
.Be(true);
var users = await db.Users.ToListAsync();
users
.Should()
.HaveCount(1, "Because one of the two users in the db was deleted");
}
public void CanAdd()
{
SPWeb web = this.RecordAddReturnSPWeb();
SPListItem item = this.RecordAddSPListItem();
Registration registration = new Registration();
registration.Title = "UnitTest";
registration.CourseId = 1234;
registration.UserId = 100;
registration.RegistrationStatus = "Pending";
MockListItemRepository.SPListItemReturnedByGet = item;
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationRepository repository = new RegistrationRepository();
int id = repository.Add(registration, web);
Assert.AreEqual(1, id);
MockManager.Verify();
}
public async Task MakeFriendRequestShouldMakeARecordInFriendshipTable()
{
// Arrange
var db = MockManager.GetMockDatabase();
var firstUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe"
};
var secondUser = new User
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Chloe"
};
await db.Users.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
var userService = new UserService(db);
// Act
var result = await userService.MakeFriendRequestAsync(firstUser.UserName, secondUser.UserName);
// Assert
result
.Should()
.Be(true);
var friendship = await db.Friendships.FirstOrDefaultAsync();
friendship
.Should()
.NotBeNull();
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="name"></param>
/// <param name="config"></param>
public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config)
{
if ((config == null))
{
throw new ArgumentNullException("You must supply a valid configuration parameters.");
}
this.m_name = name;
string userName = null, roles = null, password = null;
if (string.IsNullOrEmpty(config["description"]))
{
//throw new System.Configuration.Provider.ProviderException("You must specify a description attribute.");
}
else
{
this.m_description = config["description"];
config.Remove("description");
}
if (string.IsNullOrEmpty(config["userName"]))
{
throw new System.Configuration.Provider.ProviderException("The userName is invalid.");
}
else
{
userName = config["userName"];
config.Remove("userName");
}
if (string.IsNullOrEmpty(config["password"]))
{
//throw new System.Configuration.Provider.ProviderException("The password is invalid.");
}
else
{
password = config["password"];
config.Remove("password");
}
if (string.IsNullOrEmpty(config["roles"]))
{
throw new System.Configuration.Provider.ProviderException("The roles is invalid.");
}
else
{
roles = config["roles"];
config.Remove("roles");
}
if (config.Count > 0)
{
string extraAttribute = config.GetKey(0);
if (!String.IsNullOrEmpty(extraAttribute))
{
throw new System.Configuration.Provider.ProviderException(
"The following unrecognized attribute was found in " + Name + "'s configuration: '" +
extraAttribute + "'");
}
else
{
throw new System.Configuration.Provider.ProviderException(
"An unrecognized attribute was found in the provider's configuration.");
}
}
m_manager = new MockManager(userName, password, roles);
}
