public static IStepResult CreateStepResult(int stepNumber, ResultStatus resultStatus)
{
var stepResult = MockRepository.GenerateMock<IStepResult>();
stepResult.Stub(r => r.Number).Return(stepNumber);
stepResult.Stub(r => r.Status).Return(resultStatus);
return stepResult;
}
public virtual void PostCommand(ICommandContext commandContext, ResultStatus status)
{
// Safeguard, will throw an exception if a inherited command does not call base.PostCommand
BasePostCommandCalled = true;
commandContext.RegisterCommandLog(commandContext.Logger.Messages);
}
public void Calc()
{
var questions = StudentRecordFinder.GetQuestionsForPage(_page.ID);
foreach (var q in questions)
{
var status = (new UserResultForQuestion(_userId, q, _date)).Calc();
if(status == ResultStatus.NotIncluded)
{
SetNotIncluded();
return;
}
if (status == ResultStatus.Enqueued)
{
SetEnqueued();
return;
}
if (status == ResultStatus.Empty)
{
SetEmpty();
return;
}
if (status == ResultStatus.Pass)
_userRank += (int)q.Rank;
}
if (_userRank >= _pageRank)
_status = ResultStatus.Pass;
else
_status = ResultStatus.Fail;
}
public int Get(ResultStatus result)
{
lock (stepResults)
{
return stepResults[(int)result];
}
}
public void When_A_Comparer_Returns_A_Result_With_Status_Yes_Or_No_The_Subsequent_Comparer_Should_Never_Be_Called_Otherwise_Both_Comparers_Should_Be_Called_Once(ResultStatus status1, ResultStatus status2, int expectedNr1, int expectedNr2)
{
/* Setup */
_mockComparer1
.Setup(m => m.Compare(_mainBranch, _refBranch))
.Returns(new ComparerResult { Status = status1 });
_mockComparer2
.Setup(m => m.Compare(_mainBranch, _refBranch))
.Returns(new ComparerResult { Status = status2 });
var comparers = new List<ICommitComparer> { _mockComparer1.Object, _mockComparer2.Object };
var branchComparer = new BranchComparer(comparers);
/* Test */
var result = branchComparer.Compare(_mainBranch, _refBranch);
/* Assert */
if (expectedNr1 == 0)
{
_mockComparer1.Verify(m => m.Compare(_mainBranch, _refBranch), Times.Never);
}
else if (expectedNr1 == 1)
{
_mockComparer1.Verify(m => m.Compare(_mainBranch, _refBranch), Times.Once);
}
if (expectedNr2 == 0) {
_mockComparer2.Verify(m => m.Compare(_mainBranch, _refBranch), Times.Never);
}
else if (expectedNr2 == 1)
{
_mockComparer2.Verify(m => m.Compare(_mainBranch, _refBranch), Times.Once);
}
}
public StepResult(int stepNumber, IStepName stepName, ResultStatus stepStatus, string statusDetails = null)
{
Number = stepNumber;
StepName = stepName;
Status = stepStatus;
StatusDetails = statusDetails;
Name = stepName.Format(StepNameDecorators.Default);
}
public void AddStepResult(ResultStatus result)
{
lock (stepResults)
{
++Total;
++stepResults[(int)result];
}
}
public static WebActionResult SetActionResult(this TempDataDictionary dictionary, ResultStatus status, string message)
{
var ret = new WebActionResult
{
Status = status,
Message = message
};
dictionary[WebActionResult.ActionResultKey] = ret;
return ret;
}
protected DifferentResult(
ResultStatus status,
int destIndex,
int sourceIndex,
int length)
{
_status = status;
_destIndex = destIndex;
_sourceIndex = sourceIndex;
_length = length;
}
public void Concatenate(IResult result)
{
if (this.Status == ResultStatus.Successful && !result.IsSuccessful())
{
this.Status = ResultStatus.Unsuccessful;
}
foreach (Exception exception in result.Exceptions)
{
this._exceptions.Add(exception);
}
}
private static string GetResultCssClass(ResultStatus status)
{
switch (status)
{
case ResultStatus.Success:
return "alert alert-success";
case ResultStatus.Warning:
return "alert alert-warning";
case ResultStatus.Error:
return "alert alert-danger alert-error";
default:
throw new ArgumentOutOfRangeException("status", "Unexpected ResulStatus: " + status);
}
}
public void When_Check_Branch_Is_Called_A_Comparison_With_Result_Yes_Always_Returns_Yes_Otherwise_The_Result_Status_Is_That_Of_The_Last_Comparison(ResultStatus status1, ResultStatus status2, ResultStatus expectedStatus)
{
/* Setup */
_mockBranchComparer
.Setup(m => m.Compare(_mainBranch, _mainBranch))
.Returns(new ComparerResult { Status = status1 });
_mockBranchComparer
.Setup(m => m.Compare(_mainBranch, _refBranch))
.Returns(new ComparerResult { Status = status2 });
var selector = new ComparisonSelector(_mockBranchComparer.Object);
/* Test */
var result = selector.CheckBranch(_mainBranch, new List<Branch> { _mainBranch, _refBranch });
/* Assert */
Assert.That(result.Status, Is.EqualTo(expectedStatus));
}
private void all_features_having_all_scenarios_of_status_are_VISIBLE(ResultStatus status, [VisibleFormat]bool visible)
{
var expected = new[] { "feature", status.ToString().ToLower() };
var elements = _driver.FindFeatures().Where(f => f.GetClassNames().SequenceEqual(expected)).ToArray();
Assert.That(elements, Is.Not.Empty);
Assert.That(elements.All(s => s.Displayed == visible));
}
private void all_scenarios_with_status_other_than_STATUS_are_VISIBLE(ResultStatus status, [VisibleFormat]bool visible)
{
var elements = _driver.FindAllScenarios().Where(s => !s.HasClassName(status.ToString().ToLower())).ToArray();
Assert.That(elements, Is.Not.Empty);
Assert.That(elements.All(s => s.Displayed == visible));
}
private void the_filter_status_button_is_SELECTED(ResultStatus status, [SelectedFormat]bool selected)
{
Assert.That(_driver.FindElementById(string.Format("show{0}", status)).Selected, Is.EqualTo(selected));
}
private void a_filter_status_button_is_clicked(ResultStatus status)
{
ClickLabeledButton(string.Format("show{0}", status));
}
public void Post(Session session )
{
//(Qty + FreeSpareQty ) > (PurchOrderLine.BalQty + PurchOrderLine.FreeSpareBalQty - PurchOrderLine.PendingReceivedQty)
if ((this.ReceivedNow ) > (PurchOrderLine.BalQty))
{
DevExpress.XtraEditors.XtraMessageBox.Show(string.Format("采购单号{0}不能发单, 因为入仓数大于采购单欠数", PurchOrderLine.PurchOrderNo));
this._ResultStatus = ResultStatus.Error;
}
else if (this.ReceivedVendorDN == "")
{
DevExpress.XtraEditors.XtraMessageBox.Show(string.Format("采购单号{0}不能发单, 因为没有输入来货单号", PurchOrderLine.PurchOrderNo));
this._ResultStatus = ResultStatus.Error;
}
else
{
try
{
PurchOrderReceive pOrderReceive = new PurchOrderReceive(session);
pOrderReceive.PurchOrderLine = this.PurchOrderLine;
pOrderReceive.Qty = this.ReceivedNow;
pOrderReceive.Remark = this.ReceivedRemark;
pOrderReceive.Warehouse = this.ReceivedWarehouse;
pOrderReceive.VendorDN = this.ReceivedVendorDN;
pOrderReceive.FreeSpareQty = this.ReceivedFreeNow;
pOrderReceive.Save();
this._ResultStatus = ResultStatus.OK;
}
catch
{
this._ResultStatus = ResultStatus.Error;
}
}
}
private void the_feature_has_scenario_result_of_status(string feature, ResultStatus status)
{
_resultBuilder.ForFeature(feature).NewScenario(status);
}
//---private methods---
private HMessage InnerBuildResult(string actor, string @ref, ResultStatus? status, JToken result, HMessageOptions mOptions)
{
if (actor == null || actor.Length <= 0)
throw new MissingAttrException("actor");
if (@ref == null || @ref.Length <= 0)
throw new MissingAttrException("ref");
if (status == null)
throw new MissingAttrException("status");
HResult hResult = new HResult();
hResult.SetResult(result);
hResult.SetStatus(status);
if (mOptions == null)
mOptions = new HMessageOptions();
mOptions.Ref = @ref;
return BuildMessage(actor, "hResult", hResult, mOptions);
}
/// <summary>
/// Associate the given <see cref="ResultStatus" /> object as the result of the current step and execute the <see cref="StepProcessed"/> event.
/// </summary>
/// <param name="executeContext">The execute context.</param>
/// <param name="status">The result status.</param>
internal void RegisterResult(IExecuteContext executeContext, ResultStatus status)
{
Status = status;
//executeContext.Logger.Debug("Step timer for {0}: callbacks: {1}ms, total: {2}ms", this, CallbackWatch.ElapsedMilliseconds, MicroThreadWatch.ElapsedMilliseconds);
if (StepProcessed != null)
{
try
{
IndexFileCommand.MountDatabase(executeContext.GetOutputObjectsGroups());
StepProcessed(this, new BuildStepEventArgs(this, executeContext.Logger));
}
catch (Exception ex)
{
executeContext.Logger.Error("Exception in command " + this + ": " + ex);
}
finally
{
IndexFileCommand.UnmountDatabase();
}
}
}
public void PostPurchOrder(Session s)
{
if (this.NeedQty <= 0 || this.NeedDate == null || this.BomItem == null)
{
this._Result = ResultStatus.Error;
}
else
if (this.selected && this.Result != ResultStatus.OK)
{
try
{
PurchOrderLine poLine = new PurchOrderLine(Session);
poLine.WorkOrder = this.WorkOrder;
poLine.Item = this.BomItem;
poLine.NeedDate = this.NeedDate;
poLine.NeedQty = this.NeedQty;
poLine.FreeSpareQty = this.FreeSpareQty;
PriceDisc vendDisc = BomItem.GetPurchPrice(this.Vendor);
poLine.Price = this.Price;
if (vendDisc != null)
{
poLine.PriceQty = vendDisc.PriceQty;
poLine.PriceUnit = vendDisc.PriceUnit;
}
else
{
poLine.PriceQty = 1;
poLine.PriceUnit = Session.FindObject<Unit>(new BinaryOperator("UnitName", "HKD"));
}
poLine.Priority = 0;
poLine.Unit = this.BomItem.Unit;
poLine.Vendor = this.Vendor;
poLine.OrderType = this.WorkOrder.OrderType;
poLine.Warehouse = this.Warehouse;
if (ServerHelper.DevMode != ServerHelper.ServerDevMode.NWPRO)
{
poLine.Remark = this.WorkOrder.Remark;
}
poLine.Save();
this._Result = ResultStatus.OK;
}
catch
{
this._Result = ResultStatus.Error;
}
}
}
public void PostMoveOrder(Session s, WareHouse fromWareHouse)
{
if (this.NeedQty <= 0 || this.NeedDate == null || this.BomItem == null)
{
this._Result = ResultStatus.Error;
}
else
if (this.selected && this.Result != ResultStatus.OK)
{
try
{
MoveOrder moveOrder = new MoveOrder(Session);
moveOrder.FromWarehouse = fromWareHouse;
moveOrder.Item = this.BomItem;
moveOrder.Qty = this.NeedQty;
moveOrder.ToWarehouse = this.Warehouse;
moveOrder.WorkOrder = this.WorkOrder;
moveOrder.Remark = this.WorkOrder.WorkOrderNo;
moveOrder.Save();
this._Result = ResultStatus.OK;
}
catch
{
this._Result = ResultStatus.Error;
}
}
}
private static void SetStatus(TableRow row, ResultStatus status )
{
var c = new TableCell {Text = status.ToString()};
row.Cells.Add(c);
}
private void the_link_to_details_of_STATUS_scenarios_is_clicked(ResultStatus status)
{
_driver.FindElementsByTagName("table").First(t => t.HasClassName("summary"))
.FindElements(By.TagName("td")).First(td => td.FindElements(By.TagName("span")).Any(span => span.HasClassName(status.ToString().ToLower() + "Alert")))
.FindElements(By.TagName("a")).First().ClickWithWait();
}
private void the_feature_has_scenario_result_of_status_and_categories(string feature, ResultStatus status, [ArrayFormat]params string[] categories)
{
_resultBuilder.ForFeature(feature).NewScenario(status).WithCategories(categories);
}
private void notifyResultError(string @ref, ResultStatus resultStatus, string errorMsg, Action<HMessage> messageDelegate)
{
JObject obj = new JObject();
obj["errorMsg"] = errorMsg;
HResult result = new HResult();
result.SetStatus(resultStatus);
result.SetResult(obj);
HMessage message = new HMessage();
message.SetRef(@ref);
message.SetType("hResult");
message.SetPayload(result);
this.notifyMessage(message, messageDelegate);
}
private void RegisterCommandResult(ListStore<CommandResultEntry> commandResultEntries, CommandResultEntry result, ResultStatus status)
{
//foreach (var outputObject in result.OutputObjects.Where(outputObject => outputObject.Key.Type == UrlType.Internal))
//{
// builderContext.AssetIndexMap[outputObject.Key.Path] = outputObject.Value;
//}
Result = result;
// Only save to build cache if compilation was done and successful
if (status == ResultStatus.Successful)
{
commandResultEntries.AddValue(result);
}
}
private void AssertStep(IEnumerable<IStepResult> steps, int number, string name, ResultStatus status, string statusDetails = null)
{
var result = steps.ToArray()[number - 1];
Assert.Equal(name, result.Name);
Assert.Equal(number, result.Number);
Assert.Equal(status, result.Status);
Assert.Equal(statusDetails, result.StatusDetails);
}
protected BuildStep(ResultStatus status = ResultStatus.NotProcessed)
{
Status = status;
}
public HMessage BuildResult(string actor, string @ref, ResultStatus status, double result, HMessageOptions mOptions)
{
return InnerBuildResult(actor, @ref, status, result, mOptions);
}
