public void Save_UpdatedEntryValues_ReturnsUpdatedDataSet()
{
// Arrange
var dataSource = GetEntriesData();
var mockSet = new MockDbSet <Entry>(dataSource);
var mockContext = new Mock <GlossaryContext>();
mockContext.Setup(c => c.Set <Entry>()).Returns(mockSet.Object);
var controller = new EntryController(mockContext.Object);
Entry updatedEntry = new Entry()
{
Id = dataSource.First().Id,
Term = dataSource.First().Term,
Definition = dataSource.First().Definition
};
updatedEntry.Term = "New Term Value From User";
updatedEntry.Definition = "New Defintion Text to Replace Defintion From User Input";
// Act
controller.Save(updatedEntry);
// Assert
Assert.AreEqual(dataSource.First().Term, updatedEntry.Term);
Assert.AreEqual(dataSource.First().Definition, updatedEntry.Definition);
}
public void Index_AscendingSortParam_ReturnsAlphabeticalEntries()
{
// Arrange
var dataSource = GetEntriesData();
var mockSet = new MockDbSet <Entry>(dataSource);
var mockContext = new Mock <GlossaryContext>();
mockContext.Setup(c => c.Set <Entry>()).Returns(mockSet.Object);
var controller = new EntryController(mockContext.Object);
string sortByParam = Sort.SORT_ASCENDING;
List <Entry> sortedDataSource = dataSource.ToList();
sortedDataSource.Sort((a, b) => (a.Term.CompareTo(b.Term)));
Entry expectedFirstAlphabeticalEntry = sortedDataSource.First();
// Act
ViewResult result = controller.Index(sortByParam) as ViewResult;
List <Entry> actualModel = result.Model as List <Entry>;
// Assert
Assert.AreEqual(expectedFirstAlphabeticalEntry.Id, actualModel.First().Id);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!Page.IsPostBack)
{
if (EntryId > 0)
{
if (UserId == -1)
{
throw new Exception("Anonymous users cannot edit messages");
}
var entry = EntryController.GetEntry(EntryId, ModuleId);
if (!CanEdit)
{
if (entry.CreatedByUserID != UserId)
{
throw new Exception("You cannot edit someone else's message");
}
}
txtMessage.Text = entry.Message;
}
divApproveWarning.Visible = !Settings.AutoApprove;
}
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
public Form1()
{
InitializeComponent();
home_panel.Visible = true;
insert_panel.Visible = false;
weeklyReportPanel.Visible = false;
dailyReportPanel.Visible = false;
VisitorList = new List <Visitor>();
VisitorEntryList = new List <VisitorsEntry>();
visitorController = new VisitorController(VisitorList);
entryController = new EntryController(visitorController, VisitorEntryList);
DailyReportList = new List <VisitorsEntry>();
CurrentDate = DateTime.UtcNow.Date;
HomeDateLabel.Text = CurrentDate.ToString("dd/MM/yyyy");
entry_error_label.Visible = false;
visitor_id_error.Visible = false;
loadFile();
content_title_label.Text = "Entry Panel";
}
public void Put_WithMockedModel_ShouldBeCalledOnce()
{
// Arrange
var actualId = 4399;
var dummyString = Guid.NewGuid().ToString().Replace("-", "");
var mockRepository = new Mock <IEntryRepository>();
var dbModel = new EntryModel()
{
CategoryId = 4400,
SubCategoryId = 4401,
LexiconFunction = dummyString,
Recommendation = "delectus",
Notes = "voluptatibus",
};
mockRepository
.Setup(m => m.Update(dbModel));
var controller = new EntryController(mockRepository.Object);
// Act
controller.Put(actualId, dbModel);
// Assert
mockRepository
.Verify(m => m.Update(
It.Is <EntryModel>(
i => i.Id == actualId && i.LexiconFunction == dummyString)),
Times.Once());
}
public void Get_WithParameter42_ShouldReturnDbModel()
{
// Arrange
var actualId = 4399;
var mockRepository = new Mock <IEntryRepository>();
var expectedValue = new EntryModel()
{
Id = actualId,
CategoryId = 4401,
SubCategoryId = 4402,
LexiconFunction = "delectus",
Recommendation = "corrupti",
Notes = "aut"
};
mockRepository
.Setup(m => m.Select(actualId))
.Returns(expectedValue);
var controller = new EntryController(mockRepository.Object);
// Act
var result = controller.Get(actualId) as JsonResult;
var actualValue = (EntryModel)result.Value;
// Assert
Assert.AreEqual(expectedValue, actualValue);
}
public void Get_WithNoParameters_ShouldReturnList()
{
// Arrange
var mockRepository = new Mock <IEntryRepository>();
var expectedValue = new List <EntryModel>()
{
new EntryModel()
{
Id = 4400,
CategoryId = 4401,
SubCategoryId = 4402,
LexiconFunction = "delectus",
Recommendation = "corrupti",
Notes = "aut"
}
};
mockRepository
.Setup(m => m.SelectList())
.Returns(expectedValue);
var controller = new EntryController(mockRepository.Object);
// Act
var result = controller.Get();
var actualValue = (List <EntryModel>)result.Value;
// Assert
CollectionAssert.AreEqual(expectedValue, actualValue);
}
//Function called when starting that inits the list, given a list of all emails we need to display
public void InitList(List <EmailController> LIST)
{
//Reset the scroll bar
//CONTENT.GetComponent<RectTransform>().position = Vector3.zero;
//Populate the list
//Save position outside so they spawn in the right place everytime
Y_POS_DIFF = -Screen.height / 14f;
Vector3 POS = HEADER.transform.GetComponent <RectTransform>().position + new Vector3(0, Y_POS_DIFF, 0);
foreach (EmailController EMAIL in LIST)
{
//Instantiate a new entry
GameObject TEMP = Instantiate(ENTRY_OBJECT);
TEMP.transform.SetParent(CONTENT.transform, false);
TEMP.transform.position = POS;
//Add the values to the entry
EntryController ENTRY = TEMP.GetComponent <EntryController>();
ENTRY.EMAIL = EMAIL;
//Add this email to our list
ENTRY_LIST.Add(ENTRY);
//Add the offset to the pos for the next entry
POS += new Vector3(0, Y_POS_DIFF, 0);
}
}
public HttpResponseMessage CreateEntry(Entry e)
{
try
{
/* we're taking in an entry, and want to update the basics */
e.CreatedOnDate = DateTime.UtcNow;
e.CreatedByUserId = -1;
e.LastModifiedOnDate = DateTime.UtcNow;
e.LastModifiedByUserId = -1;
/* if we don't have a moduleId coming in, let's look it up */
if (e.ModuleId < 1)
{
//look up module
var mc = new ModuleController();
var mi = mc.GetModuleByDefinition(0, "VehiDataCollector"); //TODO: assuming PortalId=0 if moduleid =0
if (mi != null)
{
e.ModuleId = mi.ModuleID;
}
}
var vc = new EntryController();
vc.CreateEntry(e);
return(Request.CreateResponse(HttpStatusCode.OK, "valid"));
}
catch (Exception exc)
{
DnnLog.Error(exc); //todo: obsolete
return(Request.CreateResponse(HttpStatusCode.BadRequest, "error in request")); //todo: probably should localize that?
}
}
public async Task GetCurrentAsync_ValidBackendCurrentIsNull_ReturnsOkAndEmptyContent()
{
backend.GetCurrentAsync().Returns((CommandEntry)null);
var entryController = new EntryController(backend);
var contentResult = await entryController.GetCurrentAsync().ConfigureAwait(false) as OkResult;
Assert.That(contentResult, Is.Not.Null);
}
public async Task PutCurrentAsync_ValidBackendSetCurrentNotFound_ReturnsNotFoundResult()
{
backend.When(b => b.SetCurrentAsync("name")).Throw <InvalidOperationException>();
var entryController = new EntryController(backend);
var notFoundResult =
await entryController.PutCurrentAsync(new NameEntry("name")).ConfigureAwait(false) as NotFoundResult;
Assert.That(notFoundResult, Is.Not.Null);
}
public void Setup()
{
_httpContext = new MockWebContext();
_mapper = new Mock <IMapper>(MockBehavior.Strict);
_entryAccess = new Mock <IEntryAccess>();
_sut = new EntryController(_entryAccess.Object, _mapper.Object)
{
ControllerContext = MockWebContext.BasicControllerContext()
};
}
public async Task GetCurrentAsync_ValidBackend_ReturnsCurrentFromBackend()
{
backend.GetCurrentAsync().Returns(new CommandEntry()
{
Name = "backendCurrent"
});
var entryController = new EntryController(backend);
var contentResult = await entryController.GetCurrentAsync().ConfigureAwait(false) as OkNegotiatedContentResult <CommandEntry>;
Assert.That(contentResult, Is.Not.Null);
Assert.That(contentResult.Content.Name, Is.EqualTo("backendCurrent"));
}
public void Delete_NullEntryID_ThrowsHttpException()
{
// Arrange
var dataSource = GetEntriesData();
var mockSet = new MockDbSet <Entry>(dataSource);
var mockContext = new Mock <GlossaryContext>();
mockContext.Setup(c => c.Set <Entry>()).Returns(mockSet.Object);
var controller = new EntryController(mockContext.Object);
// Assert
Assert.ThrowsException <HttpException>(() => controller.Delete(null));
}
public void rptEntryListOnItemCommand(object source, RepeaterCommandEventArgs e)
{
if (e.CommandName == "Edit")
{
Response.Redirect(EditUrl(string.Empty, string.Empty, "Edit", "vid=" + e.CommandArgument));
}
if (e.CommandName == "Delete")
{
var tc = new EntryController();
tc.DeleteEntry(Convert.ToInt32(e.CommandArgument), ModuleId);
}
Response.Redirect(DotNetNuke.Common.Globals.NavigateURL());
}
public void Create_ShouldRedirectToIndex_WhenModelIsNotValid()
{
var entryDataModelRepository = Substitute.For <IRepository <EntryDataModel> >();
var controller = new EntryController(_mapper, entryDataModelRepository);
controller.ModelState.AddModelError(Fixture.Create <string>(), Fixture.Create <string>());
var result = controller.Create(Fixture.Create <EntryFormModel>()) as RedirectToRouteResult;
Assert.IsFalse(controller.ModelState.IsValid);
Assert.IsNotNull(result);
entryDataModelRepository.DidNotReceiveWithAnyArgs().Add(Arg.Any <EntryDataModel>());
StringAssert.AreEqualIgnoringCase("Index", result.RouteValues["action"].ToString());
}
public void GetLogInTest()
{
//Arrange
var userType = "Administrator";
var Admin = new Administrator();
var expectedResult = new LogInView(Admin);// Expected result is the loginview for an Admin
//Act
var result = EntryController.GetLogIn(userType); // testing the method that replace the login view with admin login view
//Assert
Assert.AreEqual(expectedResult.MyUser.GetType().Name, result.MyUser.GetType().Name); // checking if both are the same type of loginView
}
public async Task PutCurrentAsync_ValidBackend_CallsSetCurrentOnBackend()
{
backend.GetCurrentAsync().Returns(new CommandEntry()
{
Name = "backendCurrent"
});
var entryController = new EntryController(backend);
var contentResult =
await entryController.PutCurrentAsync(new NameEntry("name")).ConfigureAwait(false) as
OkNegotiatedContentResult <CommandEntry>;
Assert.That(contentResult, Is.Not.Null);
Assert.That(contentResult.Content.Name, Is.EqualTo("backendCurrent"));
await backend.Received().SetCurrentAsync(Arg.Is("name")).ConfigureAwait(false);
}
private void AdminBtn_Click(object sender, EventArgs e)
{
try
{
var myLogin = EntryController.GetLogIn("Administrator");
myLogin.Show();
this.Hide();
}
catch (Exception)
{
MessageBox.Show("Log in Error, please try later");
}
}
public void GivenNavigatorShowEntryDetailsView()
{
INavigationRepository repository = GenerateRepository();
EntryController target = new EntryController(repository);
Navigator navigator = GenerateNavigator();
ActionResult actual;
actual = target.Details(navigator);
Assert.IsNotNull(actual);
Assert.IsInstanceOfType(actual, typeof(ViewResult));
ViewResult result = actual as ViewResult;
Assert.AreEqual("Details", result.ViewName);
EntryViewModel model = result.Model as EntryViewModel;
Assert.AreEqual(model.EntryId, navigator.EntryId);
}
public void Delete_WithParameter42_ShouldBeCalledOnce()
{
// Arrange
var actualId = 8412;
var mockRepository = new Mock <IEntryRepository>();
mockRepository
.Setup(m => m.Delete(actualId));
var controller = new EntryController(mockRepository.Object);
// Act
controller.Delete(actualId);
// Assert
mockRepository
.Verify(m => m.Delete(actualId), Times.Once());
}
public void Create_ShouldRedirectToIndex_WhenAirportIsNull()
{
var entryDataModelRepository = Substitute.For <IRepository <EntryDataModel> >();
var mapper = Substitute.For <IMapper <EntryFormModel, EntryDataModel> >();
mapper.Map(Arg.Any <EntryFormModel>()).Returns(Fixture.Build <EntryDataModel>().With(x => x.Airport, null).Create());
var controller = new EntryController(mapper, entryDataModelRepository);
controller.ModelState.Clear();
var result = controller.Create(Fixture.Create <EntryFormModel>()) as RedirectToRouteResult;
Assert.IsTrue(controller.ModelState.IsValid);
Assert.IsNotNull(result);
entryDataModelRepository.DidNotReceiveWithAnyArgs().Add(Arg.Any <EntryDataModel>());
StringAssert.AreEqualIgnoringCase("Index", result.RouteValues["action"].ToString());
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
cmdAdd.NavigateUrl = EditUrl("Edit");
var showAll = Settings.AutoApprove;
if (!showAll)
{
showAll = CanEdit;
}
rpGuestbook.DataSource = EntryController.GetEntries(ModuleId, showAll);
rpGuestbook.DataBind();
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
static void Main(string[] args)
{
DiaryBook diaryBook = new DiaryBook();
var allEntries = diaryBook.GetDiaryBook();
EntryController entryController = new EntryController();
entryController.AddDiary(new DiaryEntry
{
Id = Guid.NewGuid(),
CreatedDate = DateTime.Now.AddDays(-1),
Title = "Today is the shit day",
Content = "I made a lot of bugs in project so sad."
}, allEntries);
entryController.AddDiary(new DiaryEntry
{
Id = Guid.NewGuid(),
CreatedDate = DateTime.Now,
Title = "I crushed a lady",
Content = "I crushed a lady and she is a tester who found bugs for me every day so fun haha."
}, allEntries);
foreach (var s in allEntries)
{
Console.WriteLine($"Date: {s.CreatedDate:dd/MM/yyyy}");
Console.WriteLine($"Title: {s.Title}");
Console.WriteLine($"Content: {s.Content}");
if (allEntries.IndexOf(s) != allEntries.Count - 1)
{
Console.WriteLine();
}
}
ExportDiary export = new ExportDiary();
var Timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
export.SaveToText("myDiary_" + Timestamp + ".txt", allEntries);
}
public void GivenNavigatorShowEditEntryView()
{
INavigationRepository repository = GenerateRepository();
EntryController target = new EntryController(repository);
Navigator navigator = GenerateNavigator();
ActionResult actual;
actual = target.Edit(navigator);
Assert.IsNotNull(actual);
Assert.IsInstanceOfType(actual, typeof(ViewResult));
ViewResult result = actual as ViewResult;
Assert.AreEqual("Edit", result.ViewName);
EntryViewModel model = result.Model as EntryViewModel;
Assert.AreEqual(model.EntryId, 0);
Assert.IsTrue(String.IsNullOrEmpty(model.Clue));
Assert.IsTrue(String.IsNullOrEmpty(model.Hint));
}
public void Create_ShouldRedirectToDetail_WhenModelIsValidAndAirportIsNotNull()
{
var entryDataModelRepository = Substitute.For <IRepository <EntryDataModel> >();
var entryDataModel = Fixture.Create <EntryDataModel>();
var mapper = Substitute.For <IMapper <EntryFormModel, EntryDataModel> >();
mapper.Map(Arg.Any <EntryFormModel>()).Returns(entryDataModel);
var controller = new EntryController(mapper, entryDataModelRepository);
controller.ModelState.Clear();
var result = controller.Create(Fixture.Create <EntryFormModel>()) as RedirectToRouteResult;
Assert.IsTrue(controller.ModelState.IsValid);
Assert.IsNotNull(result);
entryDataModelRepository.Received().Add(entryDataModel);
StringAssert.AreEqualIgnoringCase("Detail", result.RouteValues["action"].ToString());
}
private void btnSave_Click(object sender, EventArgs e)
{
try
{
string res = "";
if (this.txtSerie.Text == string.Empty || this.txtSequence.Text == string.Empty ||
this.txtIva.Text == string.Empty)
{
MessageError("Faltan datos obligatorios");
errorInput.SetError(txtSerie, "Introduzca un valor");
errorInput.SetError(txtSequence, "Introduzca un valor");
errorInput.SetError(txtIva, "Introduzca un valor");
}
else
{
if (this.IsNew)
{
res = EntryController.Insert(this.dtpEntryDate.Value, this.cbxTypeReceipt.Text, this.txtSerie.Text.Trim(), this.txtSequence.Text.Trim(), Convert.ToDecimal(this.txtIva.Text), "EMITIDO", IdEmployee, Convert.ToInt32(this.cbxProvider.SelectedValue), DtDetail);
}
if (res.Equals("Correcto"))
{
if (this.IsNew)
{
this.MessageOK("¡Se ha insertado el registro!");
}
}
else
{
this.MessageError(res);
}
this.IsNew = false;
this.EnableButtons();
this.ResetForm();
this.ShowData();
this.ResetItem();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + ex.StackTrace);
}
}
public void Post_WithMockedModel_ShouldReturnNewId()
{
// Arrange
var mockRepository = new Mock <IEntryRepository>();
var dbModel = new EntryModel();
var expectedValue = 4399;
mockRepository
.Setup(m => m.Insert(dbModel))
.Returns(expectedValue);
var controller = new EntryController(mockRepository.Object);
// Act
var result = controller.Post(dbModel) as JsonResult;
var actualValue = (int)result.Value;
// Assert
Assert.AreEqual(expectedValue, actualValue);
}
protected void rpGuestbook_ItemCommand(object source, RepeaterCommandEventArgs e)
{
if (e.CommandName == "Delete")
{
var entry = EntryController.GetEntry(Convert.ToInt32(e.CommandArgument), ModuleId);
if (entry != null)
{
EntryController.DeleteEntry(entry);
}
}
if (e.CommandName == "Approve")
{
var entry = EntryController.GetEntry(Convert.ToInt32(e.CommandArgument), ModuleId);
if (entry != null)
{
EntryController.Approve(entry);
}
}
Response.Redirect(DotNetNuke.Common.Globals.NavigateURL());
}
public void GivenEntryViewModelCreateNewEntry()
{
INavigationRepository repository = GenerateRepository();
EntryController target = new EntryController(repository);
EntryViewModel model = Utilities.ObjectFactory.CreateEntry(GenerateNavigator());
repository.Expect(r => r.SaveEntry(model)).Return(true);
ActionResult actual;
actual = target.Create(model);
Assert.IsNotNull(actual);
Assert.IsInstanceOfType(actual, typeof(RedirectToRouteResult));
RedirectToRouteResult result = actual as RedirectToRouteResult;
Assert.AreEqual("location_default", result.RouteName);
Assert.AreEqual("Details", result.RouteValues["Action"]);
Assert.AreEqual(model.RegionName, result.RouteValues["RegionName"]);
Assert.AreEqual(model.AreaName, result.RouteValues["AreaName"]);
Assert.AreEqual(model.LocationName, result.RouteValues["LocationName"]);
repository.VerifyAllExpectations();
}
