public void ValidIfThrowsExceptionWhenTryingToFindPersonWhoIsEmptyOrNull(string message)
{
var database = new ExtendedDatabase(shortData);
Assert.That(() => database.FindByUsername(null), Throws.ArgumentNullException, message);
Assert.That(() => database.FindByUsername(""), Throws.ArgumentNullException, message);
}
public void ExceptionIsThrownWhenUsernameInputIsNullOrEmpty()
{
ExtendedDatabase db = new ExtendedDatabase(new Person(1, "Pesho"));
Assert.Throws <ArgumentNullException>(() => db.FindByUsername(null), "Username cannot be null");
Assert.Throws <ArgumentNullException>(() => db.FindByUsername(string.Empty), "Username cannot be null");
}
public void FindByUsernameExistingPersonShouldReturnPerson()
{
var expected = pesho;
var actual = database.FindByUsername("Pesho");
Assert.That(actual, Is.EqualTo(expected));
}
public void IfNameIsNullOrEmpty_ShouldReturnException()
{
ExtendedDatabase dataBase = new ExtendedDatabase(new Person(3213, "Gosho"));
Assert.Throws <ArgumentNullException>(() => dataBase.FindByUsername(null));
Assert.Throws <ArgumentNullException>(() => dataBase.FindByUsername(string.Empty));
}
public void FindByUsername_ShouldThrow_ArgumentNullException_WhenArgumentIsNullOrEmpty()
{
Person person;
Assert.Throws <ArgumentNullException>(() => person = database.FindByUsername(null));
Assert.Throws <ArgumentNullException>(() => person = database.FindByUsername(""));
}
public void FindByUsernameWorksCorrectly()
{
Person testPerson = new Person(123, "niki");
database.Add(testPerson);
var foundPerson = database.FindByUsername("niki");
Assert.AreSame(foundPerson, testPerson);
}
public void TestFindByUsernameMethodShouldThrowExeption()
{
var database = new ExtendedDatabase(firstPerson);
Assert.Throws <InvalidOperationException>(() => database.FindByUsername("pesh11o"));
Assert.Throws <ArgumentNullException>(() => database.FindByUsername(string.Empty));
Assert.Throws <ArgumentNullException>(() => database.FindByUsername(null));
}
public void FindingPersonsByUserName()
{
string name = "Pesho";
long id = 1;
Person person = new Person(id, name);
database.Add(person);
Assert.That(database.FindByUsername(name), Is.EqualTo(person));
}
public void FindByUsername_Should_Throw_Exception_If_No_User_Is_Present_WIth_Name()
{
database.Add(Pepi);
var ex = Assert.Throws <InvalidOperationException>(() =>
{
Person somebody = database.FindByUsername("Gogi");
});
Assert.That(ex.Message, Is.EqualTo("No user is present by this username!"));
}
public void ThrowsANEWhenUsernameIsNullOrEmpty()
{
//Arrange
ExtendedDatabase db = new ExtendedDatabase
(new Person[]
{
new Person(34, "V"),
new Person(90, "M")
});
//Act && Assert
Assert.Throws <ArgumentNullException>(() => db.FindByUsername(null));
Assert.Throws <ArgumentNullException>(() => db.FindByUsername(string.Empty));
}
Find_By_Username_Method_Should_Work_Properly_With_Case_Sensitive_Arguments()
{
// Arrange
Person expectedResult = new Person(2334534634, "Test");
Person expectedresult = new Person(2352235, "test");
ExtendedDatabase database =
new ExtendedDatabase(expectedResult, expectedresult);
// Act
Person actualResult = database.FindByUsername("Test");
Person actualresult = database.FindByUsername("test");
// - Assert
Assert.AreEqual(expectedResult, actualResult);
Assert.AreEqual(expectedresult, actualresult);
}
public void FindByUsernameNullArgumentShouldThrow()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase(persons);
Assert.That(() => db.FindByUsername(null), Throws.ArgumentNullException);
}
public void CantFindByNull()
{
Person[] pp = { pesho, gosho };
var db = new ExtendedDatabase(pp);
Assert.Throws <ArgumentNullException>(() => db.FindByUsername(null));
}
public void FindByUsernameNonExistingPersonShouldThrow()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase(persons);
Assert.That(() => db.FindByUsername("Stamat"), Throws.InvalidOperationException);
}
public void FindByUsernameIsCaseSensitive()
{
var persons = new Person[] { pesho, gosho };
var db = new ExtendedDatabase(persons);
Assert.That(() => db.FindByUsername("GOSHO"), Throws.InvalidOperationException);
}
public void CantFindNonExistingName()
{
Person[] pp = { pesho, gosho };
var db = new ExtendedDatabase(pp);
Assert.Throws <InvalidOperationException>(() => db.FindByUsername("nukkkk"));
}
public void FindByUserUnknowUserNameArgument()
{
var persons = new Person(1, "a");
var db = new ExtendedDatabase(persons);
Assert.Throws <InvalidOperationException>(() => db.FindByUsername("b"));
}
public void FindByUsername_IfPresent_ShouldFindPerson()
{
var db = new ExtendedDatabase(new Person(1, "a"), new Person(2, "b"), new Person(3, "c"));
var expected = new Person(2, "b");
Assert.AreEqual(expected, db.FindByUsername("b"));
}
public void FindByUserNameMethodShouldWorkCorrectly(string message)
{
var database = new ExtendedDatabase(shortData);
var actualPerson = database.FindByUsername("Arwen");
Assert.AreEqual(shortData[0], actualPerson, message);
}
public void FindByUserNameEmptyCollectionShouldThrowException()
{
ExtendedDatabase database = new ExtendedDatabase();
Assert.Throws <InvalidOperationException>(() => database.FindByUsername("A"));
}
public void FindByUsername()
{
var person = new Person(1, "a");
var db = new ExtendedDatabase(person);
Person actual = db.FindByUsername("a");
Assert.AreEqual(person, actual);
}
public void IfNoUserIsPresentByThisUsernameShouldThrowException()
{
Person person = new Person(2, "Pesho");
ExtendedDatabase db = new ExtendedDatabase(person);
Assert.That(() => db.FindByUsername("Gosho"), Throws.InvalidOperationException);
}
public void FindByUsername_Check_ExceptionThrown_TryToFindNotExistingUsername()
{
string nameOne = "Name3";
ExtendedDatabase database = new ExtendedDatabase();
Assert.That(() => database.FindByUsername(nameOne), Throws.InvalidOperationException.With.Message.EqualTo("No user is present by this username!"));
}
public void FindByUserNameNonEmptyCollectionWithInvalidUsernameShouldThrowException()
{
ExtendedDatabase database = new ExtendedDatabase();
database.Add(new Person(1, "B"));
Assert.Throws <InvalidOperationException>(() => database.FindByUsername("A"));
}
public void FindByNameShouldReturnTheWantedNameIfItExistsInTheRecord()
{
var db = new ExtendedDatabase();
db.Add(ivan);
Assert.AreEqual(ivan, db.FindByUsername("Ivan"));
}
public void IfNameExist()
{
Person person = new Person(12, "Test");
edb = new ExtendedDatabase(person);
Person expectedPerson = edb.FindByUsername("Test");
Assert.AreEqual(expectedPerson, person);
}
public void FindByUsernameProperties()
{
var person = new Person(1, "a");
var db = new ExtendedDatabase(person);
Person actual = db.FindByUsername("a");
Assert.AreEqual(1, actual.Id);
Assert.AreEqual("a", actual.UserName);
}
public void ShouldBeFoundThePersonCurrect()
{
ExtendedDatabase dataBase = new ExtendedDatabase(new Person(3123, "gosho"));
Person person = dataBase.FindByUsername("gosho");
Person expected = new Person(3123, "gosho");
Assert.AreEqual(expected.UserName, person.UserName);
Assert.AreEqual(expected.Id, person.Id);
}
public void FindByUsernameMethodThrowIfUsernameIsNull()
{
ExtendedDatabase database = new ExtendedDatabase();
string username = null;
Assert.Throws <ArgumentNullException>(
() => database.FindByUsername(username),
"Method should throw exception when parameter username is null!");
}
public void FindByNameShouldThrowExceptionIfThereIsNoSuchPersonInTheRecord()
{
var db = new ExtendedDatabase();
db.Add(ivan);
db.Remove();
Assert.Throws <InvalidOperationException>(() => db.FindByUsername("Ivan"));
}
