public async Task <IActionResult> Edit(int id, [Bind(ExpectedResult.BindablePropertiesForEdition)] ExpectedResult expectedResult)
{
if (id != expectedResult.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(expectedResult);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpectedResultExists(expectedResult.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Details", "AcceptanceCriterias", new { Id = expectedResult.ConditionId }));
}
ViewData["ConditionId"] = new SelectList(_context.AcceptanceCriterias, "Id", "Name", expectedResult.ConditionId);
return(View(expectedResult));
}
public static void CreateClient(string regionName, string locators,
string authInit, Properties <string, string> credentials, int numConnections,
ExpectedResult expect)
{
CreateClient <object, object>(regionName, locators, authInit, credentials, true, true,
1, numConnections, null, expect);
}
public void Update_Should_Update_A_ExpectedResult()
{
_repository
.Setup(it => it.Update(It.IsAny<Int32>(), It.IsAny<String>(), It.IsAny<Int32?>(), It.IsAny<Int32>(), It.IsAny<Int32>()))
.Callback<Int32, String, Int32?, Int32, Int32>((testId, expectedValue, assertTypeId, resultIndex, id) =>
{
var tExpectedResult = _repositoryList.Find(x => x.Id==id);
tExpectedResult.TestId = testId;
tExpectedResult.ExpectedValue = expectedValue;
tExpectedResult.AssertTypeId = assertTypeId;
tExpectedResult.ResultIndex = resultIndex;
});
var tempExpectedResult = _repositoryList.Find(x => x.Id==id);
var testExpectedResult = new ExpectedResult {
Id = tempExpectedResult.Id,
TestId = tempExpectedResult.TestId,
ExpectedValue = tempExpectedResult.ExpectedValue,
AssertTypeId = tempExpectedResult.AssertTypeId,
ResultIndex = tempExpectedResult.ResultIndex};
//TODO change something on testExpectedResult
//testExpectedResult.oldValue = newValue;
_target.Update(testExpectedResult);
//Assert.AreEqual(newValue, _repositoryList.Find(x => x.Id==1).oldValue);
//TODO fail until we update the test above
Assert.Fail();
}
public void Update_Should_Update_A_ExpectedResult()
{
_repository
.Setup(it => it.Update(It.IsAny <Int32>(), It.IsAny <String>(), It.IsAny <Int32?>(), It.IsAny <Int32>(), It.IsAny <Int32>()))
.Callback <Int32, String, Int32?, Int32, Int32>((testId, expectedValue, assertTypeId, resultIndex, id) =>
{
var tExpectedResult = _repositoryList.Find(x => x.Id == id);
tExpectedResult.TestId = testId;
tExpectedResult.ExpectedValue = expectedValue;
tExpectedResult.AssertTypeId = assertTypeId;
tExpectedResult.ResultIndex = resultIndex;
});
var tempExpectedResult = _repositoryList.Find(x => x.Id == id);
var testExpectedResult = new ExpectedResult {
Id = tempExpectedResult.Id,
TestId = tempExpectedResult.TestId,
ExpectedValue = tempExpectedResult.ExpectedValue,
AssertTypeId = tempExpectedResult.AssertTypeId,
ResultIndex = tempExpectedResult.ResultIndex
};
//TODO change something on testExpectedResult
//testExpectedResult.oldValue = newValue;
_target.Update(testExpectedResult);
//Assert.AreEqual(newValue, _repositoryList.Find(x => x.Id==1).oldValue);
//TODO fail until we update the test above
Assert.Fail();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Tests the validation of a directory. </summary>
///
/// <exception cref="NotSupportedException">
/// Thrown when the requested operation is not supported.
/// </exception>
///
/// <param name="definitionFile"> The validator definition file. </param>
/// <param name="path"> Full pathname of the directory to validate. </param>
/// <param name="expectedResult"> The expected validation result. </param>
///
/// <returns> true if the test passes, false if the test fails. </returns>
private bool TestValidateDirectory(string definitionFile, string path, ExpectedResult expectedResult)
{
using (var xmlReader = XmlReader.Create(definitionFile))
{
var definition = PathValidator.DeserializeDefinition(xmlReader);
var validator = new PathValidator();
validator.Validate(definition, path);
switch (expectedResult)
{
case ExpectedResult.Valid:
return((validator.ErrorMessages.Count == 0) && (validator.WarningMessages.Count == 0));
case ExpectedResult.Warning:
return((validator.ErrorMessages.Count == 0) && (validator.WarningMessages.Count > 0));
case ExpectedResult.Error:
return((validator.ErrorMessages.Count > 0) && (validator.WarningMessages.Count == 0));
default:
throw new NotSupportedException("Unknown result type");
}
}
}
override public void CalculateFitness(ExpectedResult expectedResult)
{
double difference = 0;
double total = 0;
if (expectedResult is BitmapResult)
{
var sourceImage = (BitmapResult)expectedResult; //todo: correct code so it uses c# 8.0 mechanisms
//todo: check if images sizes are same
Int32 step = 10;
for (int y = 0; y < Height; y += step)
{
for (int x = 0; x < Width; x += step)
{
var p1 = ResultBitmap.GetPixel(x, y);
var p2 = sourceImage.Image.GetPixel(x, y);
total += 3 * 255;
//p2 = p1;
difference += Math.Abs(p1.R - p2.R) + Math.Abs(p1.G - p2.G) + Math.Abs(p1.B - p2.B);
}
}
// assuming images is 512x512
Fitness = (total - difference) / total;
}
}
/// <summary>
/// Returns the value of one of the text attributes from the expected result of the given name.
/// </summary>
public string GetExpectedResultText(EntityEnum entity, ExpectedResult expectedResult)
{
if (expectedResult == null)
{
return(string.Empty);
}
switch (entity)
{
case EntityEnum.Given:
return((expectedResult.Given == null) ? string.Empty : expectedResult.Given);
case EntityEnum.Name:
return((expectedResult.Name == null) ? string.Empty : expectedResult.Name);
case EntityEnum.Value:
return((expectedResult.Text == null) ? string.Empty : expectedResult.Text);
case EntityEnum.Condition:
return((expectedResult.Condition == null) ? string.Empty : expectedResult.Condition);
default:
return(string.Empty);
}
}
/// <summary>
/// Sets the value of one of the text attributes in the expected result of the given name.
/// </summary>
public void SetExpectedResultText(EntityEnum entity, string expectedResultName, string text)
{
ExpectedResult expectedResult = GetExpectedResult(expectedResultName);
if (expectedResult == null)
{
return;
}
switch (entity)
{
case EntityEnum.Given:
expectedResult.Given = text;
break;
case EntityEnum.Name:
expectedResult.Name = text;
break;
case EntityEnum.Value:
expectedResult.Text = text;
break;
case EntityEnum.Condition:
expectedResult.Condition = text;
expectedResult.ParseConditions();
break;
default:
break;
}
}
public async Task <IActionResult> PutExpectedResult([FromRoute] Guid id, [FromBody] ExpectedResult expectedResult)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != expectedResult.ExpectedResultId)
{
return(BadRequest());
}
_context.Entry(expectedResult).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpectedResultExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
void Ex03()
{
var thenStepCompleted = false;
Given("async ThenStep that has an assertion with Exception that does not throw any exceptions", () =>
{
Step = FixtureSteps.CreateThenStep <ArgumentNullException>(async _ =>
{
await Task.Delay(100);
thenStepCompleted = true;
});
ExpectedResult = FixtureStepResultAssertion.ForNullException(FixtureStepStatus.Passed, Step);
});
Given("async next ThenStep that asserts the Exception that is thrown at WhenStep", () =>
{
NextStep = FixtureSteps.CreateThenStep <ArgumentNullException>(async _ =>
{
await Task.Delay(100);
thenStepCompleted = true;
});
ExpectedNextResult = FixtureStepResultAssertion.ForNullException(FixtureStepStatus.Passed, NextStep);
});
When("the given ThenStep is run", () =>
{
Result = RunnerOf(Step).Run(StepResults).Build();
StepResults.Add(Result);
});
Then("the given ThenStep should be awaited", () => thenStepCompleted);
Then($"the result should be as follows:{ExpectedResult.ToDescription()}", () => FixtureStepResultAssertion.Of(Result) == ExpectedResult);
thenStepCompleted = false;
When("the given next ThenStep is run", () => Result = RunnerOf(NextStep).Run(StepResults).Build());
Then("the given next ThenStep should be awaited", () => thenStepCompleted);
Then($"the result should be as follows:{ExpectedNextResult.ToDescription()}", () => FixtureStepResultAssertion.Of(Result) == ExpectedNextResult);
}
public ExpectedResultTestRunner(ITest test, Func <ITest, TestRunner> testRunnerFactory,
IMessageBus messageBus, object[] constructorArguments, string skipReason, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, Type testNotificationType, object testClassInstance, string source)
: base(test, messageBus, constructorArguments, test.MethodInfo.ToRuntimeMethod(), skipReason, aggregator, cancellationTokenSource, testNotificationType, source)
{
_testNotificationType = testNotificationType;
_testClassInstance = testClassInstance;
ExpectedResult = new ExpectedResult(test, testRunnerFactory);
}
public void Produces(int recordCount, IDictionary <string, object> outputParams = null)
{
CheckForQuery();
SetOutputParams(outputParams);
expectedResult.RecordCount = recordCount;
expectedResults.Add(expectedResult);
expectedResult = null;
}
public async Task <int> RunAsync(IReporter reporter)
{
var pass = 0;
try
{
await ArrangeAsync();
var client = new ApiClient <TRequest, TResult>();
// test preview
if (_testPreview)
{
var previewResult = await client.PostAsync(PreviewEndpointUri, RequestData);
var previewResultErrors = AssertResult(ExpectedResult, previewResult);
var previewAccountErrors = AssertData(SetupData); // preview should not change account data
var previewErrors = Enumerable.Union <string>(previewResultErrors, previewAccountErrors);
if (previewErrors.Any())
{
reporter.ReportFail($"{GetType().Name} PREVIEW", previewErrors);
}
else
{
reporter.ReportPass($"{GetType().Name} PREVIEW");
pass++;
}
}
// test charge
if (_testActual)
{
var actualResult = await client.PostAsync(EndpointUri, RequestData);
var resultErrors = ExpectedResult.Assert(actualResult);
var dataErrors = AssertData(ExpectedData);
var testErrors = Enumerable.Union <string>(resultErrors, dataErrors);
if (testErrors.Any())
{
reporter.ReportFail(GetType().Name, testErrors);
}
else
{
reporter.ReportPass(GetType().Name);
pass++;
}
}
}
catch (Exception e)
{
reporter.ReportFail(GetType().Name, $"Unexpected Exception :: {e.GetType().Name} :: {e.Message} :: {e.Source}");
}
return(pass);
}
/// <summary>
/// Refreshes the data fields for the specific expected result.
/// </summary>
private void RefreshExpectedResultData(string expectedResultName)
{
ExpectedResult expectedResult = model.GetExpectedResult(expectedResultName);
richTextBox8.Text = model.GetExpectedResultText(EntityEnum.Given, expectedResult);
textBox4.Text = model.GetExpectedResultText(EntityEnum.Name, expectedResult);
textBox3.Text = model.GetExpectedResultText(EntityEnum.Value, expectedResult);
richTextBox5.Text = model.GetExpectedResultText(EntityEnum.Condition, expectedResult);
}
public static ExpectedResult IncludeTest(this ExpectedResult expectedResult, ITestRepository testRepository)
{
if (expectedResult.Test != null)
{
return(expectedResult);
}
expectedResult.Test = testRepository.GetDataById(expectedResult.TestId).ToList().First();
return(expectedResult);
}
public void Produces <T>(IEnumerable <T> data, IDictionary <string, object> outputParams = null)
{
CheckForQuery();
SetOutputParams(outputParams);
expectedResult.ResultSet = CreateDataTable <T>(data).CreateDataReader();
expectedResults.Add(expectedResult);
expectedResult = null;
}
public Test(string testName, TestInput input, ExpectedResult result)
{
this.TestName = testName;
steps = new List <TestStep>();
var singleStep = new TestStep();
steps.Add(singleStep);
singleStep.Arguments = input.Arguments;
singleStep.Result = result;
}
void Ex03()
{
Given("ThenStep that has an assertion with Exception that does not throw any exception", () =>
{
Step = FixtureSteps.CreateThenStep(exc => { });
ExpectedResult = FixtureStepResultAssertion.ForNullException(FixtureStepStatus.Passed, Step);
});
When("the given ThenStep is run", () => Result = RunnerOf(Step).Run(StepResults).Build());
Then($"the result should be as follows:{ExpectedResult.ToDescription()}", () => FixtureStepResultAssertion.Of(Result) == ExpectedResult);
}
public async Task <TestCase> Duplicate(long testCaseId)
{
var testCase = await _context.TestCases
.AsNoTracking()
.Include(c => c.TestActions)
.Include(c => c.TestConditions)
.Include(c => c.ExpectedResults)
.FirstOrDefaultAsync(c => c.Id == testCaseId);
var cloneTestCase = new TestCase()
{
Description = $"{testCase.Description} (copy)",
Priority = testCase.Priority,
TestModuleId = testCase.TestModuleId,
IsEnabled = testCase.IsEnabled,
IsAutomated = testCase.IsAutomated,
LastTested = null,
TestActions = new List <TestAction>(),
TestConditions = new List <TestCondition>(),
ExpectedResults = new List <ExpectedResult>()
};
foreach (var testAction in testCase.TestActions)
{
var cloneTestAction = new TestAction()
{
Description = testAction.Description,
Sequence = testAction.Sequence
};
cloneTestCase.TestActions.Add(cloneTestAction);
}
foreach (var testCondition in testCase.TestConditions)
{
var cloneTestCondition = new TestCondition()
{
Description = testCondition.Description
};
cloneTestCase.TestConditions.Add(cloneTestCondition);
}
foreach (var expectedResult in testCase.ExpectedResults)
{
var cloneExpectedResult = new ExpectedResult()
{
Description = expectedResult.Description
};
cloneTestCase.ExpectedResults.Add(cloneExpectedResult);
}
return(cloneTestCase);
}
public async Task <List <ExpectedResult> > Sort(ExpectedResult fromExpectedResult, long targetId)
{
var expectedResults = await _context.ExpectedResults.Where(a => a.TestCaseId == fromExpectedResult.TestCaseId).OrderBy(a => a.Sequence).ToListAsync();
var origin = expectedResults.SingleOrDefault(t => t.Id == fromExpectedResult.Id);
var target = expectedResults.SingleOrDefault(t => t.Id == targetId);
var result = await SortBySequence(expectedResults, origin, target);
return(result.ConvertAll(x => (ExpectedResult)x));
}
// GET: conditions/Create/1
public IActionResult Create(int?id)
{
var expectedResult = new ExpectedResult
{
ConditionId = id.GetValueOrDefault()
};
ViewData["ConditionId"] = new SelectList(_context.AcceptanceCriterias, "Id", "Name", expectedResult.ConditionId);
return(View(expectedResult));
}
public override string ToString()
{
return(string.Join(Environment.NewLine, $"{{",
$"Query:",
$"{Query}",
$"Column Names:",
$"{string.Join(", ", ColumnNames)}",
$"Expected Results:",
(ExpectedResult.Any() ? $"{string.Join(Environment.NewLine, ExpectedResult.Select(row => $"{{{string.Join(", ", row)}}}"))}" : "{}") +
$"}}"));
}
public static ExpectedResult IncludeAssertType(this ExpectedResult expectedResult,
IAssertTypeRepository assertTypeRepository)
{
if (expectedResult.AssertType != null)
{
return(expectedResult);
}
expectedResult.AssertType =
assertTypeRepository.GetDataById((int)expectedResult.AssertTypeId).ToList().First();
return(expectedResult);
}
public ActionResult Edit(int id, ExpectedResult expectedResult)
{
try
{
_dbExpectedResultRepository.Update(expectedResult);
return RedirectToAction("Index");
}
catch
{
return View(expectedResult);
}
}
public async Task <IActionResult> PostExpectedResult([FromBody] ExpectedResult expectedResult)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ExpectedResult.Add(expectedResult);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetExpectedResult", new { id = expectedResult.ExpectedResultId }, expectedResult));
}
public ActionResult Create(ExpectedResult expectedResult)
{
try
{
_dbExpectedResultRepository.Insert(expectedResult);
return(RedirectToAction("Index"));
}
catch
{
return(View(expectedResult));
}
}
public ActionResult Edit(int id, ExpectedResult expectedResult)
{
try
{
_dbExpectedResultRepository.Update(expectedResult);
return(RedirectToAction("Index"));
}
catch
{
return(View(expectedResult));
}
}
private double CalculateTotalError(List <double> outputs, int row)
{
double totalError = 0;
outputs.ForEach(output =>
{
var error = Math.Pow(output - ExpectedResult.ElementAt(row), 2);
totalError += error;
});
return(totalError);
}
public ActionResult Create(ExpectedResult expectedResult)
{
try
{
_dbExpectedResultRepository.Insert(expectedResult);
return RedirectToAction("Index");
}
catch
{
return View(expectedResult);
}
}
/// <summary>
/// 操作组件信息
/// </summary>
/// <param name="tradeMessage"></param>
/// <returns></returns>
public JObject HandleCompoent(JObject tradeMessage)
{
string itemCode = tradeMessage.GetValue("itemCode").ToString();
string pageCode = tradeMessage.GetValue("pageCode").ToString();
string relation = tradeMessage.GetValue("relation").ToString();
string executeTime = "";
bool result = true;
logger.Info("开始操作组件");
browserUntils = BrowserUntils.GetBrowser(transCode, pageCode);
logger.Info("获取浏览器对象");
if (CheckPage(transCode, pageCode) && CheckCompoent(transCode, pageCode, itemCode))
{
if (tradeMessage.GetValue("isscreen").ToString().Equals("Y"))
{
//截图
ScreenShot.Shot(browserUntils.browser);
}
if (relation != "")
{
//执行表达式相关操作
HandleRelationExpression(relation);
}
if (tradeMessage.Property("resultMap") != null && tradeMessage.GetValue("resultMap").ToString() != "")
{
//处理预期结果
ExpectedResult expectedResult = new ExpectedResult(browserUntils);
result = expectedResult.CheckExpectedResult(tradeMessage);
}
DateTime startTime = DateTime.Now;
ExecuteCompoent(tradeMessage);
DateTime endTime = DateTime.Now;
executeTime = (endTime - startTime).Milliseconds.ToString();//操作组件的时间
tradeMessage.Add("direction", executeTime);
tradeMessage.Add("checkResult", result);
}
else
{
Property.executeResult = false;
}
return(tradeMessage);
}
/// <summary>
/// Deletes the expected result from the specification and returns true if successful.
/// </summary>
public bool DeleteExpectedResult(string expectedResultName)
{
ExpectedResult expectedResult = GetExpectedResult(expectedResultName);
if (expectedResult == null)
{
return(false);
}
workingTestSpecification.ExpectedResults.Remove(expectedResultName);
workingTestSpecification.SpecificationDependencies.DeleteExpectedResultReferences(expectedResultName);
return(true);
}
public void CreateAddExpectedResultEditTest()
{
Effect effect = new Effect();
ExpectedResult req = new ExpectedResult();
ce.AddEdit(EditFactory.instance.CreateAddExpectedResultEdit(effect, req));
effect.AddExpectedResult(req);
ce.End();
ce.Undo();
Assert.IsFalse(effect.ExpectedResults.Contains(req));
ce.Redo();
Assert.IsTrue(effect.ExpectedResults.Contains(req));
}
void Ex02()
{
Given("async ThenStep that has an assertion with Exception that throws an exception", () =>
{
Step = FixtureSteps.CreateThenStep(async _ =>
{
await Task.Delay(100);
throw new Exception();
});
ExpectedResult = FixtureStepResultAssertion.ForNotNullException(FixtureStepStatus.Failed, Step);
});
When("the given ThenStep is run", () => Result = RunnerOf(Step).Run(StepResults).Build());
Then($"the result should be as follows:{ExpectedResult.ToDescription()}", () => FixtureStepResultAssertion.Of(Result) == ExpectedResult);
}
public void Update(int testId, int? expectedResultTypeId, int? assertTypeId, string expectedValue,
int resultIndex, int id)
{
using (var client = new HttpClient(_messageHandler, false))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var expectedResult = new ExpectedResult
{
TestId = testId,
ExpectedResultTypeId = expectedResultTypeId,
AssertTypeId = assertTypeId,
ExpectedValue = expectedValue,
ResultIndex = resultIndex,
Id = id
};
var response = client.PutAsync(UrlBase, expectedResult, new JsonMediaTypeFormatter()).Result;
response.EnsureSuccessStatusCode();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Tests the validation of a directory. </summary>
///
/// <exception cref="NotSupportedException">
/// Thrown when the requested operation is not supported.
/// </exception>
///
/// <param name="definitionFile"> The validator definition file. </param>
/// <param name="path"> Full pathname of the directory to validate. </param>
/// <param name="expectedResult"> The expected validation result. </param>
///
/// <returns> true if the test passes, false if the test fails. </returns>
private bool TestValidateDirectory(string definitionFile, string path, ExpectedResult expectedResult)
{
using (var xmlReader = XmlReader.Create(definitionFile))
{
var definition = PathValidator.DeserializeDefinition(xmlReader);
var validator = new PathValidator();
validator.Validate(definition, path);
switch (expectedResult)
{
case ExpectedResult.Valid:
return (validator.ErrorMessages.Count == 0) && (validator.WarningMessages.Count == 0);
case ExpectedResult.Warning:
return (validator.ErrorMessages.Count == 0) && (validator.WarningMessages.Count > 0);
case ExpectedResult.Error:
return (validator.ErrorMessages.Count > 0) && (validator.WarningMessages.Count == 0);
default:
throw new NotSupportedException("Unknown result type");
}
}
}
public void TestBatchSplittingBySizeWithErrorsOrdered()
{
_collection.Drop();
var documents = new BsonDocument[8];
for (var i = 0; i < 6; i++)
{
documents[i] = new BsonDocument { { "_id", i }, { "a", new string('x', 4 * 1024 * 1024) } };
}
documents[6] = new BsonDocument("_id", 0); // will fail
documents[7] = new BsonDocument("_id", 100);
var bulk = _collection.InitializeOrderedBulkOperation();
for (var i = 0; i < 8; i++)
{
bulk.Insert(documents[i]);
}
var exception = Assert.Throws<BulkWriteException>(() => { bulk.Execute(); });
var result = exception.Result;
Assert.IsNull(exception.WriteConcernError);
Assert.AreEqual(1, exception.WriteErrors.Count);
var writeError = exception.WriteErrors[0];
Assert.AreEqual(6, writeError.Index);
Assert.AreEqual(11000, writeError.Code);
var expectedResult = new ExpectedResult
{
InsertedCount = 6,
ProcessedRequestsCount = 7,
RequestCount = 8
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = documents.Take(6);
Assert.That(_collection.FindAll(), Is.EqualTo(expectedDocuments));
}
public void TestUpsertOneVeryLargeDocument(bool ordered)
{
_collection.Drop();
var bulk = InitializeBulkOperation(_collection, ordered);
var bigString = new string('x', 16 * 1024 * 1024 - 30);
bulk.Find(Query.EQ("key", 1)).Upsert().Update(Update.Set("x", bigString));
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "key", 1 }, { "x", bigString } }
};
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestReplaceOneWithMultipleMatchingDocuments(bool ordered)
{
_collection.Drop();
_collection.Insert(new BsonDocument("key", 1));
_collection.Insert(new BsonDocument("key", 1));
var bulk = InitializeBulkOperation(_collection, ordered);
var query = Query.EQ("key", 1);
var replacement = Update.Replace(new BsonDocument("key", 3));
bulk.Find(query).ReplaceOne(replacement);
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
MatchedCount = 1,
ModifiedCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument("key", 1),
new BsonDocument("key", 3)
};
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestUnorderedBatchWithErrors()
{
_collection.Drop();
_collection.CreateIndex(IndexKeys.Ascending("a"), IndexOptions.SetUnique(true));
var bulk = _collection.InitializeUnorderedBulkOperation();
bulk.Insert(new BsonDocument { { "b", 1 }, { "a", 1 } });
bulk.Find(Query.EQ("b", 2)).Upsert().UpdateOne(Update.Set("a", 1));
bulk.Find(Query.EQ("b", 3)).Upsert().UpdateOne(Update.Set("a", 2));
bulk.Find(Query.EQ("b", 2)).Upsert().UpdateOne(Update.Set("a", 1));
bulk.Insert(new BsonDocument { { "b", 4 }, { "a", 3 } });
bulk.Insert(new BsonDocument { { "b", 5 }, { "a", 1 } });
var exception = Assert.Throws<BulkWriteException>(() => { bulk.Execute(); });
var result = exception.Result;
var expectedResult = new ExpectedResult
{
InsertedCount = 2,
RequestCount = 6,
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var upserts = result.Upserts;
Assert.AreEqual(1, upserts.Count);
Assert.IsInstanceOf<BsonObjectId>(upserts[0].Id);
Assert.AreEqual(2, upserts[0].Index);
Assert.IsNull(exception.WriteConcernError);
Assert.AreEqual(0, exception.UnprocessedRequests.Count);
var writeErrors = exception.WriteErrors;
Assert.AreEqual(3, writeErrors.Count);
Assert.AreEqual(1, writeErrors[0].Index);
Assert.AreEqual(3, writeErrors[1].Index);
Assert.AreEqual(5, writeErrors[2].Index);
Assert.IsTrue(writeErrors.All(e => e.Code == 11000));
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "b", 1 }, { "a", 1 } },
_primary.BuildInfo.Version < new Version(2, 6, 0) ?
new BsonDocument { { "a", 2 }, { "b", 3 } } : // servers prior to 2.6 rewrite field order on update
new BsonDocument { { "b", 3 }, { "a", 2 } },
new BsonDocument { { "b", 4 }, { "a", 3 } }
};
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestRemoveWithEmptyQueryRemovesAllDocuments(bool ordered)
{
_collection.Drop();
_collection.Insert(new BsonDocument("key", 1));
_collection.Insert(new BsonDocument("key", 1));
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Find(new QueryDocument()).Remove();
var result = bulk.Execute();
var expectedResult = new ExpectedResult { DeletedCount = 2 };
CheckExpectedResult(expectedResult, result);
Assert.AreEqual(0, _collection.Count());
}
public void TestRemoveWithQueryRemovesOnlyMatchingDocuments(bool ordered)
{
_collection.Drop();
_collection.Insert(new BsonDocument("key", 1));
_collection.Insert(new BsonDocument("key", 2));
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Find(Query.EQ("key", 1)).Remove();
var result = bulk.Execute();
var expectedResult = new ExpectedResult { DeletedCount = 1 };
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new[] { new BsonDocument("key", 2) };
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestUpsertWithMultipleMatchingDocuments(bool ordered)
{
_collection.Drop();
_collection.Insert(new BsonDocument { { "_id", 1 }, { "x", 1 } });
_collection.Insert(new BsonDocument { { "_id", 2 }, { "x", 1 } });
var bulk = InitializeBulkOperation(_collection, ordered);
var query = Query.EQ("x", 1);
var update = Update.Set("x", 2);
bulk.Find(query).Upsert().Update(update);
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
MatchedCount = 2,
ModifiedCount = 2,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "_id", 1 }, { "x", 2 } },
new BsonDocument { { "_id", 2 }, { "x", 2 } }
};
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
// private methods
private void CheckExpectedResult(ExpectedResult expectedResult, BulkWriteResult result)
{
Assert.AreEqual(expectedResult.IsAcknowledged ?? true, result.IsAcknowledged);
Assert.AreEqual(expectedResult.ProcessedRequestsCount ?? expectedResult.RequestCount ?? 1, result.ProcessedRequests.Count);
Assert.AreEqual(expectedResult.RequestCount ?? 1, result.RequestCount);
if (result.IsAcknowledged)
{
Assert.AreEqual(expectedResult.DeletedCount ?? 0, result.DeletedCount);
Assert.AreEqual(expectedResult.InsertedCount ?? 0, result.InsertedCount);
Assert.AreEqual(expectedResult.MatchedCount ?? 0, result.MatchedCount);
Assert.AreEqual(expectedResult.IsModifiedCountAvailable ?? true, result.IsModifiedCountAvailable);
if (result.IsModifiedCountAvailable)
{
Assert.AreEqual(expectedResult.ModifiedCount ?? 0, result.ModifiedCount);
}
else
{
Assert.Throws<NotSupportedException>(() => { var _ = result.ModifiedCount; });
}
Assert.AreEqual(expectedResult.UpsertsCount ?? 0, result.Upserts.Count);
}
else
{
Assert.Throws<NotSupportedException>(() => { var x = result.DeletedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.InsertedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.MatchedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.ModifiedCount; });
Assert.Throws<NotSupportedException>(() => { var x = result.Upserts; });
}
}
public void TestNoJournal(bool ordered)
{
_collection.Drop();
var documents = new[]
{
new BsonDocument("x", 1)
};
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Insert(documents[0]);
var writeConcern = new WriteConcern { Journal = true };
if (IsJournalEnabled())
{
var result = bulk.Execute(writeConcern);
var expectedResult = new ExpectedResult { InsertedCount = 1, RequestCount = 1 };
CheckExpectedResult(expectedResult, result);
Assert.That(_collection.FindAll(), Is.EquivalentTo(documents));
}
else
{
if (_primary.Supports(FeatureId.WriteCommands))
{
Assert.Throws<MongoCommandException>(() => { bulk.Execute(writeConcern); });
Assert.AreEqual(0, _collection.Count());
}
else
{
var exception = Assert.Throws<BulkWriteException>(() => { bulk.Execute(writeConcern); });
var result = exception.Result;
var expectedResult = new ExpectedResult { InsertedCount = 1, RequestCount = 1 };
CheckExpectedResult(expectedResult, result);
Assert.That(_collection.FindAll(), Is.EquivalentTo(documents));
Assert.AreEqual(0, exception.UnprocessedRequests.Count);
Assert.IsNotNull(exception.WriteConcernError);
Assert.AreEqual(0, exception.WriteErrors.Count);
}
}
}
public void TestW2AgainstStandalone(bool ordered)
{
if (_primary.InstanceType == MongoServerInstanceType.StandAlone)
{
_collection.Drop();
var documents = new[] { new BsonDocument("x", 1) };
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Insert(documents[0]);
if (_primary.Supports(FeatureId.WriteCommands))
{
Assert.Throws<MongoCommandException>(() => { bulk.Execute(WriteConcern.W2); });
Assert.AreEqual(0, _collection.Count());
}
else
{
var exception = Assert.Throws<BulkWriteException>(() => { bulk.Execute(WriteConcern.W2); });
var result = exception.Result;
var expectedResult = new ExpectedResult { InsertedCount = 1, RequestCount = 1 };
CheckExpectedResult(expectedResult, result);
Assert.AreEqual(0, exception.UnprocessedRequests.Count);
Assert.AreEqual(0, exception.WriteErrors.Count);
var writeConcernError = exception.WriteConcernError;
Assert.IsNotNull(writeConcernError);
Assert.That(_collection.FindAll(), Is.EquivalentTo(documents));
}
}
}
public void TestMixedOperationsUnordered()
{
_collection.Drop();
_collection.Insert(new BsonDocument { { "a", 1 } });
_collection.Insert(new BsonDocument { { "a", 2 } });
var bulk = _collection.InitializeUnorderedBulkOperation();
bulk.Find(Query.EQ("a", 1)).Update(Update.Set("b", 1));
bulk.Find(Query.EQ("a", 2)).Remove();
bulk.Insert(new BsonDocument("a", 3));
bulk.Find(Query.EQ("a", 4)).Upsert().UpdateOne(Update.Set("b", 4));
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
DeletedCount = 1,
InsertedCount = 1,
MatchedCount = 1,
ModifiedCount = 1,
RequestCount = 4,
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var upserts = result.Upserts;
Assert.AreEqual(1, upserts.Count);
Assert.IsInstanceOf<BsonObjectId>(upserts[0].Id);
Assert.AreEqual(3, upserts[0].Index);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "a", 1 }, { "b", 1 } },
new BsonDocument { { "a", 3 } },
new BsonDocument { { "a", 4 }, { "b", 4 } }
};
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestMixedUpsertsUnordered()
{
_collection.Drop();
var bulk = _collection.InitializeUnorderedBulkOperation();
bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
bulk.Find(Query.EQ("x", 1)).RemoveOne();
bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
bulk.Find(Query.EQ("x", 1)).RemoveOne();
bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
DeletedCount = 1,
MatchedCount = 2,
RequestCount = 5,
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[0];
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
public void TestInsertOneDocument(bool ordered)
{
_collection.Drop();
var document = new BsonDocument("_id", 1);
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Insert(document);
var result = bulk.Execute();
var expectedResult = new ExpectedResult { InsertedCount = 1 };
CheckExpectedResult(expectedResult, result);
Assert.That(_collection.FindAll(), Is.EquivalentTo(new[] { document }));
}
public void TestInsertMultipleDocuments(bool ordered)
{
_collection.Drop();
var documents = new BsonDocument[]
{
new BsonDocument("_id", 1),
new BsonDocument("_id", 2),
new BsonDocument("_id", 3)
};
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Insert(documents[0]);
bulk.Insert(documents[1]);
bulk.Insert(documents[2]);
var result = bulk.Execute();
var expectedResult = new ExpectedResult { InsertedCount = 3, RequestCount = 3 };
CheckExpectedResult(expectedResult, result);
Assert.That(_collection.FindAll(), Is.EquivalentTo(documents));
}
public void TestExecuteWithExplicitWriteConcern(bool ordered, int w)
{
_collection.Drop();
var document = new BsonDocument("_id", 1);
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Insert(document);
var result = bulk.Execute(new WriteConcern { W = w });
var expectedResult = new ExpectedResult { IsAcknowledged = w > 0, InsertedCount = 1 };
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new[] { document };
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
public void TestUpsertUpdateOneOnlyAffectsOneMatchingDocument(bool ordered)
{
_collection.Drop();
_collection.Insert(new BsonDocument("key", 1));
_collection.Insert(new BsonDocument("key", 1));
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Find(Query.EQ("key", 1)).Upsert().UpdateOne(Update.Set("x", 1));
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
MatchedCount = 1,
ModifiedCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "key", 1 }, { "x", 1 } },
new BsonDocument { { "key", 1 } }
};
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void PutAsyncRequest_Return_Response()
{
// arrange
var expected = new ExpectedResult { UID = Guid.NewGuid() };
var factory = new TestWebRequestFactory();
factory.RegisterResultForUri("http://localhost", expected.ToJson());
var request = factory.Create(new Uri("http://localhost"));
var handler = new ApiRequestHandler(new ApiConfiguration("<<clientid>>", "<<clientsecret>>", "<<redirecturl>>"), new CompanyFileCredentials("user", "pass"));
// act
var receivedEntity = handler.PutAsync<Parameter, ExpectedResult>(request, new Parameter()).Result;
// assert
Assert.AreEqual(expected.UID, receivedEntity.UID);
}
public void TestUpsertUpdateUpsertsAndDoesNotAffectNonUpsertsInTheSameOperation(bool ordered)
{
_collection.Drop();
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Find(Query.EQ("key", 1)).Update(Update.Set("x", 1)); // not an upsert
bulk.Find(Query.EQ("key", 2)).Upsert().Update(Update.Set("x", 2));
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
RequestCount = 2,
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new[] { new BsonDocument { { "key", 2 }, { "x", 2 } } };
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
// repeat the same batch with the current collection contents
var bulk2 = InitializeBulkOperation(_collection, ordered);
bulk2.Find(Query.EQ("key", 1)).Update(Update.Set("x", 1)); // not an upsert
bulk2.Find(Query.EQ("key", 2)).Upsert().Update(Update.Set("x", 2));
var result2 = bulk2.Execute();
var expectedResult2 = new ExpectedResult
{
MatchedCount = 1,
RequestCount = 2,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult2, result2);
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestW0DoesNotReportErrors(bool ordered)
{
_collection.Drop();
var documents = new[]
{
new BsonDocument("_id", 1),
new BsonDocument("_id", 1)
};
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Insert(documents[0]);
bulk.Insert(documents[1]);
var result = bulk.Execute(WriteConcern.Unacknowledged);
var expectedResult = new ExpectedResult { IsAcknowledged = false, RequestCount = 2 };
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new[] { documents[0] };
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
public void TestOrderedBatchWithErrors()
{
_collection.Drop();
_collection.CreateIndex(IndexKeys.Ascending("a"), IndexOptions.SetUnique(true));
var bulk = _collection.InitializeOrderedBulkOperation();
bulk.Insert(new BsonDocument { { "b", 1 }, { "a", 1 } });
bulk.Find(Query.EQ("b", 2)).Upsert().UpdateOne(Update.Set("a", 1)); // will fail
bulk.Find(Query.EQ("b", 3)).Upsert().UpdateOne(Update.Set("a", 2));
bulk.Find(Query.EQ("b", 2)).Upsert().UpdateOne(Update.Set("a", 1));
bulk.Insert(new BsonDocument { { "b", 4 }, { "a", 3 } });
bulk.Insert(new BsonDocument { { "b", 5 }, { "a", 1 } });
var exception = Assert.Throws<BulkWriteException>(() => { bulk.Execute(); });
var result = exception.Result;
var expectedResult = new ExpectedResult
{
InsertedCount = 1,
ProcessedRequestsCount = 2,
RequestCount = 6,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var upserts = result.Upserts;
Assert.AreEqual(0, upserts.Count);
Assert.IsNull(exception.WriteConcernError);
Assert.AreEqual(4, exception.UnprocessedRequests.Count);
var writeErrors = exception.WriteErrors;
Assert.AreEqual(1, writeErrors.Count);
Assert.AreEqual(1, writeErrors[0].Index);
Assert.AreEqual(11000, writeErrors[0].Code);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "b", 1 }, { "a", 1 } }
};
Assert.That(_collection.FindAll().SetFields(Fields.Exclude("_id")), Is.EquivalentTo(expectedDocuments));
}
public void TestWTimeoutPlusDuplicateKeyError()
{
if (_primary.InstanceType == MongoServerInstanceType.ReplicaSetMember)
{
_collection.Drop();
var bulk = _collection.InitializeUnorderedBulkOperation();
bulk.Insert(new BsonDocument("_id", 1));
bulk.Insert(new BsonDocument("_id", 1));
var exception = Assert.Throws<BulkWriteException>(() => bulk.Execute(new WriteConcern { W = 999, WTimeout = TimeSpan.FromMilliseconds(1) }));
var result = exception.Result;
var expectedResult = new ExpectedResult { InsertedCount = 1, RequestCount = 2 };
CheckExpectedResult(expectedResult, result);
var writeErrors = exception.WriteErrors;
Assert.AreEqual(1, writeErrors.Count);
Assert.AreEqual(11000, writeErrors[0].Code);
Assert.AreEqual(1, writeErrors[0].Index);
var writeConcernError = exception.WriteConcernError;
Assert.AreEqual(64, writeConcernError.Code);
}
}
public void PostRequest_Return_Response()
{
// arrange
var expected = new ExpectedResult { UID = Guid.NewGuid() };
var factory = new TestWebRequestFactory();
factory.RegisterResultForUri("http://localhost", expected.ToJson());
var request = factory.Create(new Uri("http://localhost"));
var handler = new ApiRequestHandler(new ApiConfiguration("<<clientid>>", "<<clientsecret>>", "<<redirecturl>>"), new CompanyFileCredentials("user", "pass"));
// act
ExpectedResult receivedEntity = null;
handler.Post<Parameter, ExpectedResult>(request, new Parameter(), (code, location, response) => { receivedEntity = response; }, (uri, exception) => Assert.Fail(exception.Message));
// assert
Assert.AreEqual(expected.UID, receivedEntity.UID);
}
public void TestRemoveMultiple(bool ordered)
{
_collection.Drop();
var documents = new BsonDocument[]
{
new BsonDocument("_id", 1),
new BsonDocument("_id", 2),
new BsonDocument("_id", 3)
};
_collection.Insert(documents[0]);
_collection.Insert(documents[1]);
_collection.Insert(documents[2]);
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Find(Query.EQ("_id", 1)).RemoveOne();
bulk.Find(Query.EQ("_id", 3)).RemoveOne();
var result = bulk.Execute();
var expectedResult = new ExpectedResult { DeletedCount = 2, RequestCount = 2 };
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new[] { documents[1] };
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
public void TestUpsertOneVeryLargeDocument(bool ordered)
{
if (_primary.BuildInfo.Version >= new Version(2, 6, 0))
{
_collection.Drop();
var bulk = InitializeBulkOperation(_collection, ordered);
var bigString = new string('x', 16 * 1024 * 1024 - 22);
bulk.Find(Query.EQ("_id", 1)).Upsert().Update(Update.Set("x", bigString)); // resulting document will be exactly 16MiB
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "_id", 1 }, { "x", bigString } }
};
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
}
public void TestUpsertWithNoMatchingDocument(bool ordered)
{
_collection.Drop();
var id1 = ObjectId.GenerateNewId();
var id2 = ObjectId.GenerateNewId();
_collection.Insert(new BsonDocument { { "_id", id2 }, { "x", 2 } });
var bulk = InitializeBulkOperation(_collection, ordered);
bulk.Find(Query.EQ("_id", id1)).Upsert().Update(Update.Set("x", 1));
var result = bulk.Execute();
var expectedResult = new ExpectedResult
{
UpsertsCount = 1,
IsModifiedCountAvailable = _primary.Supports(FeatureId.WriteCommands)
};
CheckExpectedResult(expectedResult, result);
var expectedDocuments = new BsonDocument[]
{
new BsonDocument { { "_id", id1 }, { "x", 1 } },
new BsonDocument { { "_id", id2 }, { "x", 2 } }
};
Assert.That(_collection.FindAll(), Is.EquivalentTo(expectedDocuments));
}
