public void FindByUsernameIsWorkCorrectly()
{
string nameForSearch = "Pesho";
Person founfPerson = database.FindByUsername(nameForSearch);
Assert.AreEqual(nameForSearch, founfPerson.UserName);
}
public void FindByUsernameMustThrowExceptionWhenNameIsPresentInDatabaseButCheckCaseSensitive()
{
person = new Person(1, "Test");
emptyExtendedDatabase.Add(person);
Assert.Catch <InvalidOperationException>(() => emptyExtendedDatabase.FindByUsername("TEST"));
}
public void FindByUserName_With_EmptyDatabase()
{
string userName = "******";
Assert.That(() => { extended.FindByUsername(userName); }, Throws.InvalidOperationException);
//throw new InvalidOperationException("No user is present by this username!")
}
public void TestIfFindingByUsernameWorksCorrectly()
{
string name = "Pesho";
var person = extendedDatabase.FindByUsername(name);
Assert.That(person.UserName, Is.EqualTo(name));
}
public void If_Username_Parameter_Is_Empty_Should_Throw_Argument_Null_Exception(string findUsername)
{
//Arrange
extendedDatabase.Add(person);
//Act - Assert
Assert.Throws <ArgumentNullException>(() => extendedDatabase.FindByUsername(findUsername));
}
public void TestIfFindByUsernameMethodWorksCorrectly()
{
Person expectedPerson = database.Persons[0];
Person actualPerson = database.FindByUsername("ilko");
Assert.AreEqual(expectedPerson, actualPerson);
}
public void FindByUsernameOperatonShouldReturnCorrectPerson()
{
// Act
Person expectedPerson = firstPerson;
Person actualPerson = database.FindByUsername("firstPerson");
// Assert
Assert.AreEqual(expectedPerson, actualPerson);
}
public void Test10()
{
//person = new Person(13, "");
//Assert.Throws<ArgumentOutOfRangeException>(() =>
//{
// database.FindByUsername(person.UserName);
//});
Assert.That(() => database.FindByUsername(""), Throws.ArgumentNullException);
}
public void FindByNameUnableToFindPerson_Should_ThrowException()
{
database.Add(n1claren);
Assert.Throws <InvalidOperationException>(() =>
{
Person somebody = database.FindByUsername("lyr1c");
});
}
public void FindByUsername_Throws()
{
string username = string.Empty;
Assert.That(() => database.FindByUsername(username),
Throws.ArgumentNullException.With.Message.Contains("Username parameter is null!"));
}
public void FindByUsername()
{
Person person = new Person(1, "Gosho");
db.Add(person);
Person samePersonExpected = db.FindByUsername("Gosho");
Assert.That(samePersonExpected.UserName, Is.EqualTo(person.UserName), "Person doesn't match real person.");
}
public void DatabaseShouldThrowExcpFindBy()
{
Assert.Throws <ArgumentNullException>(() => extendedDatabase.FindByUsername(""));
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindByUsername("Bont"));
Assert.Throws <ArgumentOutOfRangeException>(() => extendedDatabase.FindById(-1));
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindById(100));
}
public void FindByUsernameShouldReturnCorrectPerson()
{
Person pesho = new Person(2, "Pesho");
database.Add(pesho);
Person personToFind = database.FindByUsername("Pesho");
Assert.AreEqual(pesho, personToFind);
}
public void When_AddPerson_Should_IncreaseCounter()
{
Person person = new Person(32, "Angel");
database.Add(person);
Assert.AreEqual(database.Count, 1);
Person returnPrson = database.FindByUsername("Angel");
Assert.That(returnPrson.Id, Is.EqualTo(person.Id));
Assert.That(returnPrson.UserName, Is.EqualTo(person.UserName));
}
public void FindByUsernameIsCaseSensitive()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
Assert.That(() => db.FindByUsername("GOSHO"), Throws.InvalidOperationException);
}
public void FindByUsernameNonExistingPersonShouldThrow()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
Assert.That(() => db.FindByUsername("Stamat"), Throws.InvalidOperationException);
}
public void FindByUsernameNullArgumentShouldThrow()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
Assert.That(() => db.FindByUsername(null), Throws.ArgumentNullException);
}
public void FindByNameShouldWorkProperly()
{
string expectedName = "Pesho1";
Person actualPerson = fullDatabase.FindByUsername("Pesho1");
Assert.AreEqual(expectedName, actualPerson.UserName);
}
public void RemoveOperationShouldRemoveLastElement()
{
const long lastPersonId = 13579;
const string lastPersonUsername = "******";
const int expectedCount = 2;
//Arrange
List <Person> persons = new List <Person>()
{
new Person(12345, "Ivan"),
new Person(67890, "Asen"),
new Person(13579, "Gosho")
};
ExtendedDatabase.ExtendedDatabase database = new ExtendedDatabase.ExtendedDatabase(persons.ToArray());
//Act
database.Remove();
//Assert
int actualCount = database.Count;
Assert.AreEqual(expectedCount, actualCount);
Assert.Throws <InvalidOperationException>(() => database.FindById(lastPersonId));
Assert.Throws <InvalidOperationException>(() => database.FindByUsername(lastPersonUsername));
}
public void FindByUsernameDoesntContainsUsername()
{
CreatePeople(5);
ExtendedDatabase.ExtendedDatabase extendedDatabase = new ExtendedDatabase.ExtendedDatabase(people);
Assert.Throws <InvalidOperationException>(() => extendedDatabase.FindByUsername("100"));
}
public void FindByUsernameTakesNullOrEmptyName(string name)
{
CreatePeople(5);
ExtendedDatabase.ExtendedDatabase extendedDatabase = new ExtendedDatabase.ExtendedDatabase(people);
Assert.Throws <ArgumentNullException>(() => extendedDatabase.FindByUsername(name));
}
public void SearchedIfNameIsValid()
{
Person personX = new Person(1, "x");
string name = "x";
this.exDatabase.Add(personX);
Person expectedPerson = exDatabase.FindByUsername(name);
Assert.AreEqual(expectedPerson, personX);
}
public void FindByUsernameExistingPersonShouldReturnPerson()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase.ExtendedDatabase(persons);
var expected = pesho;
var actual = db.FindByUsername("Pesho");
Assert.That(actual, Is.EqualTo(expected));
}
public void FindByUsername_ReturnExpectedUser_WhenUserExissts()
{
Person person = new Person(1, "Kristian");
this.database.Add(person);
Person dbPerson = database.FindByUsername(person.UserName);
Assert.That(person, Is.EqualTo(dbPerson));
}
public void FindByUsernameWorksProperly()
{
CreatePeople(5);
ExtendedDatabase.ExtendedDatabase extendedDatabase = new ExtendedDatabase.ExtendedDatabase(people);
Person expectedPerson = new Person(0, "0");
Person actualPerson = extendedDatabase.FindByUsername("0");
Assert.AreEqual(expectedPerson.UserName, actualPerson.UserName);
Assert.AreEqual(expectedPerson.Id, actualPerson.Id);
}
public void CheckFindByUsernameThrowExceptionIfNoSuchPersonInCollection()
{
var persons = new Person[] { new Person(1, "A"), new Person(2, "B") };
extendedDatabase = new ExtendedDatabase(persons);
var name = "C";
Assert.Throws <InvalidOperationException>(() =>
{
extendedDatabase.FindByUsername(name);
});
}
public void SearchingForUsernameNotExistingInTheDatabase_ShouldThrowException()
{
//Arrange
var database = new ExtendedDatabase.ExtendedDatabase();
var userOne = new Person(1, "Existing");
//Act
database.Add(userOne);
//Assert
Assert.Throws <InvalidOperationException>(() => database.FindByUsername("NotExisting"));
}
public void SearchingForNullUsernameInTheDatabase_ShouldThrowException()
{
//Arrange
var database = new ExtendedDatabase.ExtendedDatabase();
var userOne = new Person(1, "user");
//Act
database.Add(userOne);
//Assert
Assert.Throws <ArgumentNullException>(() => database.FindByUsername(null));
}
public void CheckFindByUsernameWorksCorrect()
{
var persons = new Person[] { new Person(1, "A"), new Person(2, "B") };
extendedDatabase = new ExtendedDatabase(persons);
var person = new Person(1, "A");
var personName = person.UserName;
var searchedPerson = extendedDatabase.FindByUsername(personName);
Assert.AreEqual(person.UserName, searchedPerson.UserName);
}
public void CheckFindByUserNameThrowExceptionIfNameIsNull()
{
var persons = new Person[] { new Person(1, "A"), new Person(2, "B") };
extendedDatabase = new ExtendedDatabase(persons);
string name = string.Empty;
Assert.Throws <ArgumentNullException>(() =>
{
extendedDatabase.FindByUsername(name);
});
}
