public void GetByPastDueHaspKey()
{
List <HaspKey> GetByActive;
var GetByActiveExpected = new List <HaspKey>
{
new HaspKey
{
Id = 2,
InnerId = 2,
Number = "uz-3",
IsHome = true,
TypeKey = TypeKey.Pro,
}
};
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
ClearTable.KeyFeatures(db);
haspKeyDAO = new DbHaspKeyDAO(db);
db.HaspKeys.AddRange(CreateListEntities.HaspKeys());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.SaveChanges();
GetByActive = haspKeyDAO.GetByPastDue();
}
CollectionAssert.AreEqual(GetByActive, GetByActiveExpected);
}
public void GetByClientHaspKey()
{
List <HaspKey> getByClient;
var getByClientExpected = new List <HaspKey>
{
CreateNew(1),
};
var client = new Client
{
Id = 1,
Name = "Ivanov Ivan",
};
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
ClearTable.KeyFeatures(db);
ClearTable.KeyFeatureClients(db);
haspKeyDAO = new DbHaspKeyDAO(db);
db.HaspKeys.AddRange(CreateListEntities.HaspKeys());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.KeyFeatureClients.AddRange(CreateListEntities.KeyFeatureClients());
db.SaveChanges();
getByClient = haspKeyDAO.GetByClient(client);
}
CollectionAssert.AreEqual(getByClient, getByClientExpected);
}
public void GetByFeatureClient()
{
List <Client> getByFeature;
using (var db = new EntitesContext())
{
ClearTable.Features(db);
ClearTable.KeyFeatures(db);
ClearTable.Clients(db);
ClearTable.KeyFeatureClients(db);
clientL = Get(db);
db.Features.AddRange(CreateListEntities.Features());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.Clients.AddRange(CreateListEntities.Clients());
db.KeyFeatureClients.AddRange(CreateListEntities.KeyFeatureClients());
db.SaveChanges();
getByFeature = clientL.GetByFeature(new Feature
{
Id = 1,
Number = 1,
Name = "qwe",
});
}
CollectionAssert.AreEqual(getByFeature, CreateListEntities.Clients());
}
public void ErroneousArgumentSaveKeyFeatureClient()
{
KeyFeatureClient keyFeatureClient = CreateNew();
using (var db = new EntitesContext())
{
ClearTable.KeyFeatureClients(db);
keyFeatureClientL = Get(db);
keyFeatureClient.Initiator = null;
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.Save(keyFeatureClient));
keyFeatureClient.Initiator = string.Empty;
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.Save(keyFeatureClient));
keyFeatureClient.Initiator = "____";
keyFeatureClient.IdClient = 0;
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.Save(keyFeatureClient));
keyFeatureClient.IdClient = -2;
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.Save(keyFeatureClient));
keyFeatureClient.IdClient = 2;
keyFeatureClient.IdKeyFeature = 0;
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.Save(keyFeatureClient));
keyFeatureClient.IdKeyFeature = -2;
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.Save(keyFeatureClient));
}
}
public void SaveNullHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => haspKeyL.Save(null));
}
}
public void GetByErroneousIdHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyL = Get(db);
Assert.ThrowsException <ArgumentException>(() => haspKeyL.GetById(erroneousId));
}
}
public void UpdateNullKeyFeatureClient()
{
using (var db = new EntitesContext())
{
keyFeatureClientL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => keyFeatureClientL.Update(null));
}
}
public void GetByErroneousIdKeyFeatureClient()
{
using (var db = new EntitesContext())
{
keyFeatureClientL = Get(db);
Assert.ThrowsException <ArgumentException>(() => keyFeatureClientL.GetById(erroneousId));
}
}
public void SaveNullKeyFeature()
{
using (var db = new EntitesContext())
{
keyFeatureL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => keyFeatureL.Save(null));
}
}
public void AddNullClient()
{
using (var db = new EntitesContext())
{
clientDAO = new DbClientDAO(db);
Assert.ThrowsException <ArgumentNullException>(() => clientDAO.Add(null));
}
}
public void GetByErroneousIdClient()
{
using (var db = new EntitesContext())
{
clientDAO = new DbClientDAO(db);
Assert.ThrowsException <ArgumentException>(() => clientDAO.GetById(erroneousId));
}
}
public void UpdateNullFeature()
{
using (var db = new EntitesContext())
{
featureDAO = new DbFeatureDAO(db);
Assert.ThrowsException <ArgumentNullException>(() => featureDAO.Update(null));
}
}
public void GetByNullClientHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyDAO = new DbHaspKeyDAO(db);
Assert.ThrowsException <ArgumentNullException>(() => haspKeyDAO.GetByClient(null));
}
}
public void SaveNullClient()
{
using (var db = new EntitesContext())
{
clientL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => clientL.Save(null));
}
}
public void RemoveErroneousIdFeature()
{
using (var db = new EntitesContext())
{
featureL = Get(db);
Assert.ThrowsException <ArgumentException>(() => featureL.Remove(erroneousId));
}
}
public void GetByErroneousNumberKeyClient()
{
using (var db = new EntitesContext())
{
clientL = Get(db);
Assert.ThrowsException <ArgumentException>(() => clientL.GetByNumberKey(erroneousId));
}
}
public void RemoveErroneousIdClient()
{
using (var db = new EntitesContext())
{
clientL = Get(db);
Assert.ThrowsException <ArgumentException>(() => clientL.Remove(erroneousId));
}
}
public void GetByNullFeatureClient()
{
using (var db = new EntitesContext())
{
clientL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => clientL.GetByFeature(null));
}
}
public void AddNullHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyDAO = new DbHaspKeyDAO(db);
Assert.ThrowsException <ArgumentNullException>(() => haspKeyDAO.Add(null));
}
}
public void AddNullKeyFeature()
{
using (var db = new EntitesContext())
{
kfDAO = new DbKeyFeatureDAO(db);
Assert.ThrowsException <ArgumentNullException>(() => kfDAO.Add(null));
}
}
public void RemoveErroneousIdKeyFeature()
{
using (var db = new EntitesContext())
{
kfDAO = new DbKeyFeatureDAO(db);
Assert.ThrowsException <ArgumentException>(() => kfDAO.Remove(erroneousId));
}
}
public void RemoveErroneousIdHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyDAO = new DbHaspKeyDAO(db);
Assert.ThrowsException <ArgumentException>(() => haspKeyDAO.Remove(erroneousId));
}
}
public void GetByErroneousIdFeaturey()
{
using (var db = new EntitesContext())
{
featureDAO = new DbFeatureDAO(db);
Assert.ThrowsException <ArgumentException>(() => featureDAO.GetById(erroneousId));
}
}
public void GetByNumberKeyNoDBClient()
{
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
clientL = Get(db);
Assert.IsNull(clientL.GetByNumberKey(2));
}
}
public void GetByIdNoDBHaspKey()
{
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyDAO = new DbHaspKeyDAO(db);
Assert.IsNull(haspKeyDAO.GetById(1));
}
}
public void RemoveNoDBHaspKey()
{
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKeyL.Save(CreateNew());
Assert.IsFalse(haspKeyL.Remove(123));
}
}
public void RemoveNoDBClient()
{
using (var db = new EntitesContext())
{
ClearTable.Clients(db);
clientL = Get(db);
clientL.Save(CreateNew());
Assert.IsFalse(clientL.Remove(123));
}
}
public void RemoveNoDBKeyFeature()
{
using (var db = new EntitesContext())
{
ClearTable.KeyFeatures(db);
kfDAO = new DbKeyFeatureDAO(db);
kfDAO.Add(CreateNew());
Assert.IsFalse(kfDAO.Remove(123));
}
}
public void AddDuplicateHaspKey()
{
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyDAO = new DbHaspKeyDAO(db);
haspKeyDAO.Add(CreateNew());
Assert.AreEqual(haspKeyDAO.Add(CreateNew()), -1);
}
}
public void RemoveNoDBHaspKey()
{
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyDAO = new DbHaspKeyDAO(db);
haspKeyDAO.Add(CreateNew());
Assert.IsFalse(haspKeyDAO.Remove(123));
}
}
