public async Task Test__SaveMany()
{
// Arrange
var model1 = new DummyModel
{
Name = "Foo", Children = new List <Nested>
{
new Nested()
}
};
var model2 = new DummyModel
{
Name = "Foo", Children = new List <Nested>
{
new Nested()
}
};
// Act
var result = await _repository.For <DummyModel>().Save(model1, model2);
// Assert
Assert.Equal(new List <DummyModel> {
model1, model2
}, result);
Assert.Equal(new List <DummyModel> {
model1, model2
}, await _repository.For <DummyModel>().GetAll(model1.Id, model2.Id));
}
public void OwnedEntityRequired()
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
var options = new DbContextOptionsBuilder <OwnedEntitytContext>();
options.EnableSensitiveDataLogging();
options.UseSqlite(connection);
var dbContext = new OwnedEntitytContext(options.Options);
dbContext.Database.EnsureCreated();
DummyModel model;
try
{
model = new DummyModel {
OwnedModel = new OwnedModel()
};
dbContext.Set <DummyModel>().Add(model);
dbContext.SaveChanges();
}
catch (DbUpdateException ex)
{
Debug.WriteLine(ex.Message);
model = null;
}
Assert.Null(model);
}
public void Page_With_Default_Action(string virtualUrl)
{
// Arrange
var pathData = new PathData();
var mapper = new Mock <IControllerMapper>();
var container = new Mock <IContainer>();
mapper.Setup(x => x.GetControllerName(typeof(DummyController))).Returns("Dummy");
container.Setup(x => x.GetInstance <IDocumentSession>()).Returns(_store.OpenSession());
// Act
IPathData data;
using (var session = _store.OpenSession()) {
// create and store a new page model
var pageModel = new DummyModel {
Metadata = { Url = "page" }
};
session.Store(pageModel);
session.SaveChanges();
var resolver = new PathResolver(session, pathData, mapper.Object, container.Object);
data = resolver.ResolvePath(new RouteData(), virtualUrl);
}
// Assert
Assert.NotNull(data);
Assert.AreEqual("index", data.Action);
Assert.AreEqual("Dummy", data.Controller);
}
public void OnEnable(MemberItem member)
{
if (m_IsDummy)
{
Member = member;
DummyModel = member.LoadDoc(TextOrig, Language, false, false);
if (Language == LanguageUtil.ELanguage.English)
{
DummyModel.EnforcePunctuation();
}
DummyModel.SanitizeForEditing();
}
else
{
Member = member;
member.LoadDoc(Language);
member.LoadDoc(TextCurrent, Language, false);
if (Language == LanguageUtil.ELanguage.English)
{
Model.EnforcePunctuation();
}
Model.SanitizeForEditing();
if (Diff == null)
{
Diff = new StringDiff();
}
Diff.Compare(TextOrig, TextCurrent);
}
}
private IEnumerable <DummyModel> GenerateDummyData()
{
var models = new List <DummyModel>();
for (int i = 1; i <= TotalRecords; i++)
{
var model = new DummyModel();
model.DummyID = i;
model.Name = GetWords(random.Next(1, 2)) + " --- " + i;
model.Description = GetWords(random.Next(3, 5)) + " --- " + i;
if (i % 10 == 0)
{
model.Date = null;
model.DateTime = null;
model.Currency = null;
}
else
{
model.Date = new DateTime(random.Next(1970, 2001), random.Next(10, 12), random.Next(1, 29));
model.DateTime = new DateTime(random.Next(1970, 2001), random.Next(10, 12), random.Next(1, 29),
random.Next(0, 23), random.Next(0, 59), random.Next(0, 59));
model.Currency = random.Next(1, 1000);
}
model.EmailAddress = GetWords(random.Next(3, 5)) + "@" + GetWords(random.Next(1, 2)) + ".com" + " --- " + i;
model.Time = new DateTime(1970, 1, 1, random.Next(0, 23), random.Next(0, 59), random.Next(0, 59));
model.Url = "http://www." + GetWords(random.Next(3, 5)) + "." + GetWords(1) + " --- " + i;
model.Decimal1 = (float)random.NextDouble();
models.Add(CreateDummyModel(i));
}
return(models.OrderBy(m => m.DummyID));
}
private DummyModel CreateDummyModel(int i)
{
var model = new DummyModel();
model.DummyID = i;
model.Name = GetWords(random.Next(1, 2)) + " --- " + i;
model.Description = GetWords(random.Next(3, 5)) + " --- " + i;
if (i % 10 == 0)
{
model.Date = null;
model.DateTime = null;
model.Currency = null;
}
else
{
model.Date = new DateTime(random.Next(1970, 2001), random.Next(10, 12), random.Next(1, 29));
model.DateTime = new DateTime(random.Next(1970, 2001), random.Next(10, 12), random.Next(1, 29),
random.Next(0, 23), random.Next(0, 59), random.Next(0, 59));
model.Currency = random.Next(1, 1000);
}
model.EmailAddress = GetWords(random.Next(3, 5)) + "@" + GetWords(random.Next(1, 2)) + ".com" + " --- " + i;
model.Time = new DateTime(1970, 1, 1, random.Next(0, 23), random.Next(0, 59), random.Next(0, 59));
model.Url = "http://www." + GetWords(random.Next(3, 5)) + "." + GetWords(1) + " --- " + i;
model.Decimal1 = (float)random.NextDouble();
return(model);
}
public async Task PutObjectAsync_should_create_object_with_metadata()
{
// Arrange
IBucketObjectService classUnderTest = new BucketObjectService(_s3BucketClient);
var dummyModel = new DummyModel()
{
Age = 1,
CreatedDate = DateTime.Now,
FullName = "Fizz Buzz",
Id = Guid.NewGuid()
};
var contentBody = _jsonSerializationService.SerializeObject(dummyModel);
var putObjectRequest = new PutObjectRequestBuilder(BucketName, FileNameWithMetadata, contentBody);
putObjectRequest.WithMetadata("biz", "bat");
putObjectRequest.WithMetadata("fizz", "buzz");
// Act
var response = await classUnderTest
.PutObjectAsync(putObjectRequest.Create());
// Assert
Assert.IsTrue(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
public void CanIgnoreAllDatasetsForDataSource()
{
var ignoredDatasets =
new List <XmlInvolvedObjectsMatchCriterionIgnoredDatasets>
{
new XmlInvolvedObjectsMatchCriterionIgnoredDatasets
{
ModelName = "MODEL1"
}
};
var criteria = new InvolvedObjectsMatchCriteria(ignoredDatasets);
var model1 = new DummyModel("model1");
DummyTableDataset dataset11 = model1.AddDataset(new DummyTableDataset("dataset1"));
DummyTableDataset dataset12 = model1.AddDataset(new DummyTableDataset("dataset2"));
DummyTableDataset dataset13 = model1.AddDataset(new DummyTableDataset("dataset3"));
var model2 = new DummyModel("model2");
DummyTableDataset dataset21 = model2.AddDataset(new DummyTableDataset("dataset1"));
Assert.True(criteria.IgnoreDataset(dataset11));
Assert.True(criteria.IgnoreDataset(dataset12));
Assert.True(criteria.IgnoreDataset(dataset13));
Assert.False(criteria.IgnoreDataset(dataset21));
}
public static void Main(string[] args)
{
Console.WriteLine("New population!");
Console.WriteLine("Walking through it...");
var population = DummyModel.Populate(5, 2, 6);
/*Func<List<DummyModel>, Task>*/ aMap walkThrough = null;
walkThrough = async(l) =>
{
await Task.Run(async() =>
{
foreach (var d in l)
{
var ofst = int.Parse(d.Value.Split('-')[0]);
Console.WriteLine(string.Empty.PadLeft(ofst, '-') + "> " + d.Value);
if (d.HasChildrens)
{
await walkThrough(d.Childrens);
}
}
});
};
walkThrough(population).Wait();
Console.WriteLine("Done");
}
public static void Main(string[] args)
{
HR("Map");
var a = new int[] { 2, 4, 6, 7, 8, 10, 67 };
var b = new StringBuilder[]
{
new StringBuilder(),
new StringBuilder()
};
var c = (a.Map(i => b[0].AppendFormat("{0} ", i))
.Map(i => ++ i)
.Map(i => b[1].AppendFormat("{0} ", i))
.Convert(i => (double)i));
b.Map((o) => Console.WriteLine(o));
c.Map(i => i * 2.1)
.Map(i => Console.Write("{0} ", i));
HR("Convert, Map");
DummyModel.Populate(20, 0, 0)
.Convert(m => new
{
id = int.Parse(m.Value.Split('-')[1]) + 1
})
.Map(o => Console.Write("{0} ", o.id));
HR("Req");
DummyModel.Populate(4, 1, 3)
.Recursion(m =>
{
var ofst = int.Parse(m.Value.Split('-')[0]);
Console.WriteLine(string.Empty.PadLeft(ofst, '-') + "> " + m.Value);
return(m.Childrens);
});
HR("ToDictionary");
CreepyModel.Populate(10)
.Map(o => o.ToDictionary()
.Map(p => Console.WriteLine("Creepy.{0} = {1}",
p.Key, p.Value)));
HR("ToDictionary.Selector");
CreepyModel.Populate(12)
.Map(o => o.ToDictionary(s => new
{
Id = s.IntProp,
Value = s.TextProp
})
.Map(n => Console.WriteLine("New.{0} = {1}",
n.Key, n.Value)));
}
public ActionResult Reset()
{
var model = new DummyModel();
SetDummy(model);
return(PartialView("Nails", model));
}
public void Add(string value)
{
var dummy = new DummyModel {
Id = ++IdCounter, Name = value
};
this._dB.DummyModel.Add(dummy);
this._dB.SaveChanges();
}
public void Array_RefType()
{
var collection = new DummyModel[Size];
for (int i = 0; i < Size; i++)
{
collection[i] = new DummyModel();
}
}
private DummyModel GetDummy()
{
var model = new DummyModel();
if (Session["Dummy"] != null)
{
model = (DummyModel)Session["Dummy"];
}
return(model);
}
public void RemoveMethodShouldTriggerRemoveMessage()
{
var collectionMock = new ListCollectionObserver <DummyModel>(consoleWrapperMock.Object);
var item = new DummyModel(1, "SMith", Grade.Bronze);
collectionMock.Add(item);
collectionMock.Remove(item);
var text = "Item with id: 1 was removed from collection";
consoleWrapperMock.Verify(a => a.WriteLine(text), Times.Once);
}
public Record <DummyRelatedModel, Guid> CreateRecord(DummyModel entity)
{
var dummy = new DummyRelatedModel
{
Id = Guid.NewGuid(),
ParentId = entity.Id
};
Console.WriteLine("Creating related records");
return(new Record <DummyRelatedModel, Guid>(dummy, dummy.Id));
}
public void ChangeMethodShouldTriggerRemoveMessage()
{
var collectionMock = new ListCollectionObserver <DummyModel>(consoleWrapperMock.Object);
var item = new DummyModel(1, "John", Grade.Gold);
collectionMock.Add(item);
collectionMock.Change(new DummyModel(1, "Mike", Grade.Silver));
var text = "Name was changed from John to Mike \n" +
$"Grade was changed from Gold to Silver";
consoleWrapperMock.Verify(a => a.WriteLine(text), Times.Once);
}
// GET: Home
public ActionResult Index()
{
var model = new DummyModel()
{
Description = "This string is stored in RavenDB"
};
var modelId = _raven.Store(model);
var modelFromDb = _raven.Load <DummyModel>(modelId);
return(View(modelFromDb));
}
public void ArrayPool_RefType()
{
var myPool = ArrayPool <DummyModel> .Shared;
var collection = myPool.Rent(Size);
for (int i = 0; i < Size; i++)
{
collection[i] = new DummyModel();
}
myPool.Return(collection);
}
public void GlobalValuesActionFilterAttribute_Should_Fill_ModelHeader_With_CorrectValues()
{
var resourceList = new List <StringResource>();
// Generate Test Data
Random random = new Random();
for (int i = 0; i < 200; i++)
{
resourceList.Add(new StringResource()
{
AvailableOnClientSide = random.Next() % 2 == 0,
Name = Lorem.Sentence(),
Value = Lorem.Sentence(),
CultureCode = "en-US"
});
}
DummyModel model = new DummyModel();
Mock <IResourceManager> resMan = new Mock <IResourceManager>();
Mock <ISettingContainer <AppSetting> > appSettings = new Mock <ISettingContainer <AppSetting> >();
Mock <IContextProvider> contextProvider = new Mock <IContextProvider>();
ResultExecutingContext context = new ResultExecutingContext();
context.Controller = new DummyController();
context.Controller.ViewData = new ViewDataDictionary()
{
Model = model
};
resMan.Setup(m => m.GetStringResources()).Returns(resourceList);
resMan.Setup(m => m.GetAvailableCultureList()).Returns(new List <string>()
{
"en-US"
});
appSettings.Setup(m => m.Contains(It.IsAny <string>())).Returns(false);
contextProvider.Setup(m => m.LanguageCode).Returns("en-US");
Mock <ISettingManager> settingManagerMock = new Mock <ISettingManager>();
settingManagerMock.Setup(m => m.GetContainer <AppSetting>()).Returns(appSettings.Object);
GlobalValuesActionFilterAttribute attribute = new GlobalValuesActionFilterAttribute(settingManagerMock.Object,
contextProvider.Object, resMan.Object);
attribute.OnResultExecuting(context);
Assert.Equal(model.Header.ClientResources.Count, resourceList.Count(rs => rs.AvailableOnClientSide == true));
var testKey = model.Header.ClientResources.First().Key;
var testVal = model.Header.ClientResources.First().Value;
Assert.True(resourceList.Any(rs => rs.Name == testKey));
Assert.True(resourceList.Any(rs => rs.Value == testVal));
}
public async Task <IActionResult> PutDummyModel(long id, [FromBody] DummyModel dummyModel)
{
var entry = _context.DummyModel.FirstOrDefault(x => x.Id == id);
entry.FirstName = dummyModel.FirstName;
entry.LastName = dummyModel.LastName;
entry.Username = dummyModel.Username;
entry.Password = dummyModel.Password;
await _context.SaveChangesAsync();
return(NoContent());
}
public static void Map(DummyModel source, DummyViewModel target)
{
target.DummyID = source.DummyID;
target.Name = source.Name;
target.Description = source.Description;
target.Date = source.Date;
target.Time = source.Time;
target.Currency = source.Currency;
target.EmailAddress = source.EmailAddress;
target.Url = source.Url;
target.Decimal1 = source.Decimal1;
target.DateTime = source.DateTime ?? DateTime.MinValue;
}
public void Expected_the_Same_Id_and_Name(int id, string name)
{
// Arrange
// Act
var dummyModel = new DummyModel()
{
Id = id,
Name = name,
};
// Assert
dummyModel.Id.Should().Be(id);
dummyModel.Name.Should().Be(name);
}
public IActionResult Post([FromBody] DummyModel item)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = _repo.Add(item);
if (result is AlreadyExistsError err)
{
return(Forbid(err.Message));
}
return(StatusCode(201));
}
public void Should_Map_From_DummyModel_To_DummyModelOutput(int id, string name)
{
// Arrange
// Act
var dummyModel = new DummyModel()
{
Id = id,
Name = name,
};
var dummyModelOutput = this._mapper.Map <DummyModelOutput>(dummyModel);
// Assert
dummyModelOutput.Id.Should().Be(id);
dummyModelOutput.Name.Should().Be(name);
}
public async void InsertModel()
{
DummyModel dummy = new DummyModel();
dummy.Key = "Nieuw model";
dummy.EntityStatus = EntityStatus.Active;
dummy.Name = "New";
dummy.Inner.InnerName = "newInner";
var createdDummy = await _service.CreateAsync(dummy);
var history = await _service.GetHistoryAsync(dummy.Key);
Assert.Equal(1, history.Count());
Assert.NotEqual(null, createdDummy);
}
public async Task Test__Get()
{
// Arrange
var model = new DummyModel
{
Name = "Foo", Children = new List <Nested>
{
new Nested()
}
};
// Act
await _repository.For <DummyModel>().Save(model);
// Assert
Assert.Equal(model, await _repository.For <DummyModel>().Get(model.Id));
}
public void POCOParserProps()
{
var obj = new DummyModel();
var parser = new POCOParser(obj.GetType());
var res = parser.Parse();
Assert.AreEqual(nameof(obj.ID), res.ElementAt(0).Name);
Assert.AreEqual(obj.ID.GetType().Name, res.ElementAt(0).DataType);
Assert.AreEqual(nameof(obj.Check), res.ElementAt(1).Name);
Assert.AreEqual(obj.Check.GetType().Name, res.ElementAt(1).DataType);
Assert.AreEqual(nameof(obj.Number), res.ElementAt(2).Name);
Assert.AreEqual(obj.Number.GetType().Name, res.ElementAt(2).DataType);
Assert.AreEqual(nameof(obj.Text), res.ElementAt(3).Name);
Assert.AreEqual(obj.Text.GetType().Name, res.ElementAt(3).DataType);
}
public async Task Test__DeleteWhere()
{
// Arrange
var model = new DummyModel
{
Name = "Foo", Children = new List <Nested>
{
new Nested()
}
};
await _repository.For <DummyModel>().Save(model);
// Act
await _repository.For <DummyModel>().Delete(x => x.Id == model.Id);
// Assert
Assert.Empty(await _repository.For <DummyModel>().GetAll());
}
public async Task Test__UpdateWhere()
{
// Arrange
var model = new DummyModel
{
Name = "Foo", Children = new List <Nested>
{
new Nested()
}
};
await _repository.For <DummyModel>().Save(model);
// Act
model.Name = "Bar";
await _repository.For <DummyModel>().Update(x => x.Id == model.Id, model);
// Assert
Assert.Equal(model, await _repository.For <DummyModel>().Get(x => x.Id == 1));
}
