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);
haspKeyL = Get(db);
db.HaspKeys.AddRange(CreateListEntities.HaspKeys());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.KeyFeatureClients.AddRange(CreateListEntities.KeyFeatureClients());
db.SaveChanges();
getByClient = haspKeyL.GetByClient(client);
}
CollectionAssert.AreEqual(getByClient, getByClientExpected);
}
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);
haspKeyL = Get(db);
db.HaspKeys.AddRange(CreateListEntities.HaspKeys());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.SaveChanges();
GetByActive = haspKeyL.GetByPastDue();
}
CollectionAssert.AreEqual(GetByActive, GetByActiveExpected);
}
public void GetByNullClientHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => haspKeyL.GetByClient(null));
}
}
public void RemoveErroneousIdHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyL = Get(db);
Assert.ThrowsException <ArgumentException>(() => haspKeyL.Remove(erroneousId));
}
}
public void SaveNullHaspKey()
{
using (var db = new EntitesContext())
{
haspKeyL = Get(db);
Assert.ThrowsException <ArgumentNullException>(() => haspKeyL.Save(null));
}
}
public void GetByIdNoDBHaspKey()
{
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
Assert.IsNull(haspKeyL.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 SaveHaspKey()
{
bool add;
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
add = haspKeyL.Save(CreateNew());
}
Assert.IsTrue(add);
}
public HaspKeyModel(IFactoryLogic factoryLogic)
{
if (factoryLogic == null)
{
throw new ArgumentNullException(nameof(factoryLogic));
}
db = Context.GetContext(); if (db == null)
{
throw new ArgumentNullException(nameof(db));
}
keyLogic = factoryLogic.CreateHaspKey(db);
}
public void GetAllEmptyHaspKey()
{
var getAll = new List <HaspKey>();
var haspKeysExpected = new List <HaspKey>();
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
getAll = haspKeyL.GetAll();
}
CollectionAssert.AreEqual(getAll, haspKeysExpected);
}
public void SaveDuplicateHaspKey()
{
bool add;
HaspKey haspKey = CreateNew();
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKeyL.Save(haspKey);
add = haspKeyL.Save(haspKey);
}
Assert.IsFalse(add);
}
public void GetByIdHaspKey()
{
HaspKey getById;
HaspKey keyExpected = CreateNew(1);
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKeyL.Save(CreateNew());
getById = haspKeyL.GetById(1);
}
Assert.AreEqual(getById, keyExpected);
}
public KeyFeatureClientModel(IFactoryLogic factoryLogic)
{
this.factoryLogic = factoryLogic ?? throw new ArgumentNullException(nameof(factoryLogic));
db = Context.GetContext();
if (db == null)
{
throw new ArgumentNullException(nameof(db));
}
clientLogic = this.factoryLogic.CreateClient(db);
keyFeatureClientLogic = this.factoryLogic.CreateKeyFeatureClient(db);
haspKeyLogic = this.factoryLogic.CreateHaspKey(db);
keyFeatureLogic = this.factoryLogic.CreateKeyFeature(db);
featureLogic = this.factoryLogic.CreateFeature(db);
}
public void UpdateDuplicateHaspKey()
{
var haspKey = CreateNew();
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKeyL.Save(haspKey);
haspKey.InnerId = 12;
haspKeyL.Save(haspKey);
Assert.IsFalse(haspKeyL.Update(CreateNew(2)));
}
}
public void UpdateNoDBHaspKey()
{
var keyNoDB = new HaspKey
{
Id = 234,
InnerId = 1546,
Number = "uz-265",
IsHome = false,
TypeKey = TypeKey.NetTime,
};
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKeyL.Save(CreateNew());
Assert.IsFalse(haspKeyL.Update(keyNoDB));
}
}
public void GetAllHaspKey()
{
var getAll = new List <HaspKey>();;
var haspKeys = CreateListEntities.HaspKeys();
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
foreach (var key in haspKeys)
{
haspKeyL.Save(key);
}
getAll = haspKeyL.GetAll();
}
CollectionAssert.AreEqual(getAll, haspKeys);
}
public void RemoveHaspKey()
{
bool remove;
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
ClearTable.KeyFeatures(db);
ClearTable.KeyFeatureClients(db);
haspKeyL = Get(db);
db.HaspKeys.AddRange(CreateListEntities.HaspKeys());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.KeyFeatureClients.AddRange(CreateListEntities.KeyFeatureClients());
db.SaveChanges();
remove = haspKeyL.Remove(1);
}
Assert.IsTrue(remove);
}
public void UpdateHaspKey()
{
bool update;
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKeyL.Save(CreateNew());
update = haspKeyL.Update(new HaspKey
{
Id = 1,
InnerId = 23,
Number = "u2322",
IsHome = false,
TypeKey = TypeKey.Time,
});
}
Assert.IsTrue(update);
}
public void ErroneousArgumentSaveHaspKey()
{
HaspKey haspKey = CreateNew();
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
haspKeyL = Get(db);
haspKey.InnerId = -1456;
Assert.ThrowsException <ArgumentException>(() => haspKeyL.Save(haspKey));
haspKey.InnerId = 234;
haspKey.Number = null;
Assert.ThrowsException <ArgumentException>(() => haspKeyL.Save(haspKey));
haspKey.Number = string.Empty;
Assert.ThrowsException <ArgumentException>(() => haspKeyL.Save(haspKey));
haspKey.Number = "____";
haspKey.TypeKey = (TypeKey)12;
Assert.ThrowsException <ArgumentException>(() => haspKeyL.Save(haspKey));
}
}
public void GetByActiveHaspKey()
{
List <HaspKey> GetByActive;
var GetByActiveExpected = new List <HaspKey>
{
CreateNew(1),
};
using (var db = new EntitesContext())
{
ClearTable.HaspKeys(db);
ClearTable.KeyFeatures(db);
haspKeyL = Get(db);
db.HaspKeys.AddRange(CreateListEntities.HaspKeys());
db.KeyFeatures.AddRange(CreateListEntities.KeyFeatures());
db.SaveChanges();
GetByActive = haspKeyL.GetByActive();
}
CollectionAssert.AreEqual(GetByActive, GetByActiveExpected);
}
public void NullEntitesContextHaspKey()
{
Assert.ThrowsException <ArgumentNullException>(() => haspKeyL = Get(null));
}
