public void Save(Bike bike)
{
using (var unitofwork = (IFileUnitOfWork)Training.Workshop.UnitOfWork.UnitOfWork.Start())
{
unitofwork.Database.bikes.Add(bike);
unitofwork.Commit();
}
}
public void TestMethod1()
{
Training.Workshop.Data.Context.Current.RepositoryFactory = new Training.Workshop.Data.SQL.RepositoryFactory();
Training.Workshop.UnitOfWork.Context.Current.UnitOfWorkFactory = new Training.Workshop.Data.SQL.SQLSystemUnitOfWork.SQLSystemDatabaseUnitofWorkFactory();
//Constructing check
var bike = new Bike();
Assert.AreEqual(bike.Manufacturer, null, "manufacturer field after bike creating is not empty");
Assert.AreEqual(bike.Mark, null, "mark field after bike creating is not empty");
Assert.AreEqual(bike.OwnerID, 0, "ownerid field after bike creating is not null");
Assert.AreEqual(bike.ConditionState, null, "condition after bike creating is not empty");
}
/// <summary>
/// Find Only one bike by bikeID
/// </summary>
/// <param name="mark"></param>
/// <returns></returns>
public Bike Find(int bikeID)
{
var bike = new Bike();
using (var unitofwork = (ISQLUnitOfWork)Training.Workshop.UnitOfWork.UnitOfWork.Start())
{
using (var command = unitofwork.Connection.CreateCommand())
{
command.CommandText = "usp_FindBikebybikeID";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("bikeID", bikeID);
var manufacturer = new SqlParameter("manufacturer", SqlDbType.VarChar);
manufacturer.Direction = ParameterDirection.Output;
manufacturer.Size = 30;
command.Parameters.Add(manufacturer);
var mark = new SqlParameter("mark", SqlDbType.VarChar);
mark.Direction = ParameterDirection.Output;
mark.Size = 50;
command.Parameters.Add(mark);
var bikeyear = new SqlParameter("bikeyear", SqlDbType.DateTime);
bikeyear.Direction = ParameterDirection.Output;
command.Parameters.Add(bikeyear);
var ownerid = new SqlParameter("ownerid", 0);
ownerid.Direction = ParameterDirection.Output;
command.Parameters.Add(ownerid);
var conditionstate = new SqlParameter("conditionstate", SqlDbType.VarChar);
conditionstate.Direction = ParameterDirection.Output;
conditionstate.Size = 30;
command.Parameters.Add(conditionstate);
command.ExecuteNonQuery();
//adding data from database to bike
bike.Manufacturer = command.Parameters["manufacturer"].Value.ToString();
bike.Mark = command.Parameters["mark"].Value.ToString();
if (command.Parameters["bikeyear"].Value.ToString() != "")
{
bike.BikeYear = Convert.ToDateTime(command.Parameters["bikeyear"].Value.ToString());
bike.OwnerID = int.Parse(command.Parameters["ownerid"].Value.ToString());
}
bike.ConditionState = command.Parameters["conditionstate"].Value.ToString();
}
}
return bike;
}
/// <summary>
/// Create a new bike in the system
/// </summary>
/// <param name="manufacturer"></param>
/// <param name="mark"></param>
/// <param name="owner"></param>
/// <param name="year"></param>
/// <returns></returns>
public virtual Bike Create(string manufacturer, string mark, string ownername, int bikeyear,string conditionstate)
{
//if owner with ownername exist in database-add bike to database and return it,else return bike with empty fields.
int ownerID=Data.Context.Current.RepositoryFactory.GetUserRepository().GetUserIDbyUsername(ownername);
if (ownerID != 0)
{
var bike = new Bike
{
Manufacturer = manufacturer,
Mark = mark,
OwnerID = ownerID,
BikeYear = new DateTime(bikeyear,1,1),
ConditionState = conditionstate
};
Data.Context.Current.RepositoryFactory.GetBikeRepository()
.Save(bike);
return bike;
}
else return new Bike();
}
public void TestMethod1()
{
//Configuration of Database
//Work with SQL Database,if need work with file database need to comment Factory;
Training.Workshop.Data.Context.Current.RepositoryFactory = new Training.Workshop.Data.SQL.RepositoryFactory();
Training.Workshop.UnitOfWork.Context.Current.UnitOfWorkFactory = new Training.Workshop.Data.SQL.SQLSystemUnitOfWork.SQLSystemDatabaseUnitofWorkFactory();
//existing user who have moto
var existinguserwithmoto="glareone";
var existinguserwithoutmoto="HOFMYVBPLVTUVLLBDYBR";
var notexistinguser="******";
//Check bike search by username
List<Bike> listofbikes=Training.Workshop.Data.Context.Current.
RepositoryFactory.GetBikeRepository().Search(existinguserwithmoto);
Assert.IsTrue(listofbikes.Count != 0, "user had bikes,but listofbikes are empty");
//Check bike search by username
listofbikes = Training.Workshop.Data.Context.Current.
RepositoryFactory.GetBikeRepository().Search(existinguserwithoutmoto);
Assert.IsTrue(listofbikes.Count == 0, "user hasn't any bikes,but something wrong");
listofbikes = Training.Workshop.Data.Context.Current.
RepositoryFactory.GetBikeRepository().Search(notexistinguser);
Assert.IsTrue(listofbikes.Count == 0, "user are not exist,but something wrong");
//Check Retrieve all bikes and bikes by users.
List<Bike> listofallbikes = Training.Workshop.Data.Context.Current.
RepositoryFactory.GetBikeRepository().RetrieveAllBikes();
//TODO
//Check ALL bikes by userID
//check Save(Bike bike) method
var randomel=new Random();
var bikeyear=new DateTime(randomel.Next(1985,2013),randomel.Next(1,12),randomel.Next(1,25));
string[] newManufacturer = new string[] { "Honda", "Suzuki", "Yamaha", "Ducatti", "Kawasaki", "Aprilia", "BMW", "MVAgusta"};
string[] newMark=new string[]{"CBR600","CB500","Vulcan1300","Intruder1700","Hayabusa","Bandit650","Bandit1200","VFR800","VTR1000"};
string[] newconditionstate=new string[]{"good","bad","oilflush","enginebroke","lossed","paint need","valves adjustment","carburetors cleaning","technical service"};
//take combination
//do that for checking Delete(string mark,int ownerid) method
string newcurrentmark = newMark[randomel.Next(0, 8)];
int newcurrentuserID = randomel.Next(12, 40);
string newcurrentmanufacturer=newManufacturer[randomel.Next(0,7)];
string newcondition = newconditionstate[randomel.Next(0, 8)];
var newbike = new Bike
{
Manufacturer = newcurrentmanufacturer,
Mark = newcurrentmark,
OwnerID = newcurrentuserID,
BikeYear = bikeyear,
ConditionState = newcondition
};
Training.Workshop.Data.Context.Current.RepositoryFactory.GetBikeRepository().
Save(newbike);
//Check that bike Save method works right
listofbikes=Training.Workshop.Data.Context.Current.RepositoryFactory.GetBikeRepository().
RetrieveAllBikes();
CollectionAssert.Contains(listofbikes, newbike,"listofbikes doesn't contain creating bike");
//check Update method works right
Training.Workshop.Data.Context.Current.RepositoryFactory.GetBikeRepository().
UpdateCondition(newcurrentmanufacturer, newcurrentmark, newcurrentuserID, newcondition, "GOOD!TEST!");
//search bike and check new condition
listofbikes = Training.Workshop.Data.Context.Current.RepositoryFactory.GetBikeRepository().
RetrieveAllBikes();
var newbikeforcheckcondition = new Bike
{
Manufacturer = newcurrentmanufacturer,
Mark = newcurrentmark,
OwnerID = newcurrentuserID,
BikeYear = bikeyear,
ConditionState = "GOOD!TEST!"
};
Assert.IsTrue(listofbikes.Contains(newbikeforcheckcondition));
//check that Delete method works right
Training.Workshop.Data.Context.Current.RepositoryFactory.GetBikeRepository().
Delete(newcurrentmark, newcurrentuserID);
listofbikes = Training.Workshop.Data.Context.Current.RepositoryFactory.GetBikeRepository().
RetrieveAllBikes();
CollectionAssert.DoesNotContain(listofallbikes, newbike, "listofbikes contain bike,error");
}
public void TestMethod1()
{
string username = "******";
var listofpermission = new List<string> { "ReadAll", "WriteAll", "DeleteAll" };
var role1 = new Role { Name = "administrator", Permissions = listofpermission };
var roles = new List<Role> { role1 };
string[] repositorytestrole = new string[] { "administrator" };
string repositorytestusername = "******";
string repositorytestpassword = "******";
int value = 1;
string repositorytestmark = "CBR600RR";
string repositorytestmanufacturer = "HONDA";
var repositorytestbikeyear = new DateTime(2000, 1, 1);
string repositorytestcondition = "normal_for_test";
//configuring userrepository mock
var userrepository = new Mock<IUserRepository>();
userrepository.Setup(m => m.GetUser(repositorytestusername, repositorytestpassword)).Returns(new User { Username = repositorytestusername, Roles = roles });
userrepository.Setup(m => m.RetrieveAllUsers()).Returns(new List<User> { new User { Username = repositorytestusername, Roles = roles } });
userrepository.Setup(m => m.GetAllUsers()).Returns(new List<User> { new User { Username = repositorytestusername, Roles = roles } });
userrepository.Setup(m => m.GetUserIDbyUsername(username)).Returns(value);
userrepository.Setup(m => m.GetUserIDbyUsername(repositorytestusername)).Returns(2);
userrepository.Setup(m => m.SaveNewUser(repositorytestusername, repositorytestpassword, repositorytestrole)).Returns(true);
//configuring bikerepository mock
var bikerepository = new Mock<IBikeRepository>();
var currentbike = new Bike
{
Manufacturer = repositorytestmanufacturer,
Mark = repositorytestmark,
BikeYear = repositorytestbikeyear,
ConditionState = repositorytestcondition,
OwnerID = 1
};
bikerepository.Setup(m => m.RetrieveAllBikes()).Returns(new List<Bike> { currentbike });
bikerepository.Setup(m => m.Search(repositorytestusername)).Returns(new List<Bike> { currentbike });
//configuring repository factory mock object in all repositories
var repositoryfactory = new Mock<IRepositoryFactory>();
repositoryfactory.Setup(m => m.GetUserRepository()).Returns(userrepository.Object);
repositoryfactory.Setup(m => m.GetBikeRepository()).Returns(bikerepository.Object);
//Start Domain and Services testing with Repository isolation.
ServiceLocator.RegisterService<IUserService>(typeof(UserService));
//Service->RepositoryFactory->Mock Object
Training.Workshop.Data.Context.Current.RepositoryFactory = repositoryfactory.Object;
var user = User.Create(repositorytestusername, repositorytestpassword, repositorytestrole);
Assert.IsTrue(user.Username == repositorytestusername);
Assert.IsTrue(user.Roles == roles);
//Stop userrepository testing
//Start bikerepository testing
ServiceLocator.RegisterService<IBikeService>(typeof(BikeService));
var bike1 = Bike.Create(repositorytestmanufacturer, repositorytestmark, repositorytestusername, value, repositorytestcondition);
Assert.IsTrue
(
bike1.Manufacturer == repositorytestmanufacturer &&
bike1.Mark == repositorytestmark &&
bike1.OwnerID == 2 &&
bike1.ConditionState == repositorytestcondition
);
var bike2 = Bike.Create(repositorytestmark, repositorytestmanufacturer, repositorytestusername, value, repositorytestcondition);
Assert.IsFalse
(
bike2.Manufacturer == repositorytestmanufacturer &&
bike2.Mark == repositorytestmark &&
bike2.OwnerID == value &&
bike2.ConditionState == repositorytestcondition
);
//Stop bikerepository testing
//Domain testing with service mock.
//cunfiguring services
var iuserservice = new Mock<IUserService>();
string newusername = "******";
iuserservice.Setup(m => m.GetUser(newusername, newusername)).Returns(new User { Username = newusername, Roles = roles });
iuserservice.Setup(m => m.Create("newuser", "newuser", repositorytestrole)).Returns(new User { Username = "******", Roles = roles });
iuserservice.Setup(m => m.Create("newuser2", "newuser2", repositorytestrole)).Returns(new User { Username = "******", Roles = roles });
//right choise
iuserservice.Setup(m => m.GetUser(newusername, newusername)).Returns(new User { Username = "******", Roles = roles });
//right
userrepository.Setup(m => m.GetUser(newusername, newusername)).Returns(new User { Username = newusername, Roles = roles });
userrepository.Setup(m => m.SaveNewUser("newuser", "newuser", repositorytestrole)).Returns(false);
userrepository.Setup(m => m.SaveNewUser(newusername, newusername, repositorytestrole)).Returns(true);
//Start Domain testing
//uncorrect SaveNewUser(username,password,roles),uncorrect data in User
var newuser1 = User.Create("newuser", "newuser", repositorytestrole);
Assert.IsFalse
(
newuser1.Username == newusername &&
newuser1.Roles == roles
);
//correct SaveNewUser(), correct data in User
var newuser2 = User.Create(newusername, newusername, repositorytestrole);
userrepository.Setup(m => m.SaveNewUser(newusername, newusername, repositorytestrole)).Returns(true);
Assert.IsTrue
(
newuser2.Username == newusername &&
newuser2.Roles == roles
);
//uncorrect SaveNewUser(), correct data in User
var newuser3 = User.Create("newuser2", "newuser2", repositorytestrole);
Assert.IsFalse
(
newuser3.Username == newusername &&
newuser3.Roles == roles
);
//Stop Domain testing
}
/// <summary>
/// Save new bike in SQL Database
/// </summary>
/// <param name="bike"></param>
public void Save(Bike bike)
{
using (var unitofwork = (ISQLUnitOfWork)Training.Workshop.UnitOfWork.UnitOfWork.Start())
{
using (var command = unitofwork.Connection.CreateCommand())
{
command.CommandText = "InsertBike";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("Manufacturer", bike.Manufacturer);
command.Parameters.AddWithValue("Mark", bike.Mark);
command.Parameters.AddWithValue("BikeYear", bike.BikeYear);
command.Parameters.AddWithValue("ownerID", bike.OwnerID);
command.Parameters.AddWithValue("ConditionState", bike.ConditionState);
command.ExecuteNonQuery();
}
}
}
/// <summary>
/// Saves bike into repository
/// </summary>
/// <param name="user"></param>
public void Save(Bike user)
{
}
