public void GivenInitialDataset()
{
using (var ctx = new GlossaryEntities())
{
if (ctx.Definitions.Any())
{
var defs = from d in ctx.Definitions select d;
ctx.Definitions.RemoveRange(defs);
}
ctx.Definitions.AddRange(
new Definition[]
{
new Definition {
Term = "abyssal plain", TermDefinition = "The ocean floor off the continental margin, usually very flat with a slight slope."
},
new Definition {
Term = "accrete", TermDefinition = "To add terranes (small land masses or pieces of crust) to another, usually larger, land mass."
},
new Definition {
Term = "alkaline", TermDefinition = "Term pertaining to highly basic, as opposed to acidic, substance"
}
});
ctx.SaveChanges();
}
}
public IHttpActionResult PostDefinitions([FromBody] object json)
{
Debug.WriteLine(json);
var definitions = new System.Web.Script.Serialization.JavaScriptSerializer().Deserialize <Models.DefinitionModel[]>(json.ToString());
try
{
var records = 0;
foreach (var def in definitions)
{
// Validate
if (def.Term.Length >= 2 && def.Term.Length <= 80 &&
def.TermDefinition.Length >= 10)
{
var existing = (from d in db.Definitions where d.Term == def.Term select d).FirstOrDefault();
if (existing == null)
{
db.Definitions.Add(new Definition {
Term = def.Term, TermDefinition = def.TermDefinition
});
}
else
{
existing.TermDefinition = def.TermDefinition;
}
}
else
{
return(BadRequest($"Validation error in definition: {def.Term}"));
}
records++;
}
db.ChangeTracker.DetectChanges();
var count = db.SaveChanges(); // commit
return(Json(new { RecordsUpdated = count, RecordsTotal = records }));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(BadRequest(ex.Message));
}
}
// CREATE: Glossary
public ActionResult Create([DataSourceRequest] DataSourceRequest request, Glossary item)
{
try
{
if (ModelState.IsValid)
{
db.Glossary.Add(item);
db.SaveChanges();
return(Json(new[] { item }.ToDataSourceResult(request, ModelState)));
}
else
{
return(Json(db.Glossary.ToList()));
}
}
catch (Exception ex)
{
return(Json(ex.Message));
}
}
private void InitializeDatabase()
{
using (var db = new GlossaryEntities())
{
foreach (var item in db.Glossary.ToList())
{
db.Glossary.Remove(item);
}
db.SaveChanges();
}
}
public void UpdateTest()
{
using (var db = new GlossaryEntities())
{
db.Glossary.Add(new Glossary {
Term = "Term1", Definition = "Def1"
});
db.SaveChanges();
var item = db.Glossary.First();
item.Term = "Term2";
var result = (JsonResult)controller.Update(new DataSourceRequest(), item);
var item2 = db.Glossary.FirstOrDefault(q => q.Id == item.Id);
Assert.IsNotNull(item2);
Assert.AreEqual(item2.Term, "Term2");
}
}
private void ReadInitialDefs()
{
using (var db = new GlossaryEntities())
{
foreach (var def in GivenTerms())
{
var existing = (from d in db.Definitions where d.Term == def.Term select d).FirstOrDefault();
if (existing == null)
{
db.Definitions.Add(new Definition {
Term = def.Term, TermDefinition = def.TermDefinition
});
}
else
{
existing.TermDefinition = def.TermDefinition;
}
}
db.SaveChanges();
}
}
public void ReadTest()
{
using (var db = new GlossaryEntities())
{
db.Glossary.Add(new Glossary {
Term = "Term1", Definition = "Def1"
});
db.Glossary.Add(new Glossary {
Term = "Term2", Definition = "Def2"
});
db.SaveChanges();
}
var result = (JsonResult)controller.Read(new DataSourceRequest());
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Data, typeof(DataSourceResult));
Assert.IsNotNull(result.Data);
Assert.IsInstanceOfType(((DataSourceResult)result.Data).Data, typeof(IEnumerable));
Assert.IsNotNull(((DataSourceResult)result.Data).Data);
Assert.AreEqual(((List <Glossary>)((DataSourceResult)result.Data).Data).Count, 2);
}
