public void DeleteProduct_AttemptToDeleteEntity_Success()
{
Arrange arr = ArrangeTests();
arr.ApiCarPartController.DeleteProduct(arr.CarPart);
arr.Mocka.Verify(m => m.DeleteEntity(arr.CarPart), Times.Once);
}
/// <summary>
/// Asserts the case
/// </summary>
/// <param name="expected">expected Arrange</param>
/// <param name="actual">actual Arrange</param>
public override void Assert(Arrange expected, Arrange actual)
{
if (this.Expected.Exists.HasValue)
{
this.ExpectedValue = "Node exists: " + this.Expected.Exists;
this.ActualValue = "Node exists: " + actual.HttpResponse.ExistsNode(this.Actual.Query, this.Actual.Attribute);
}
else
{
if (!this.IsList)
{
this.ExpectedValue = this.GetValue(expected, this.Expected);
this.ActualValue = this.GetValue(actual, this.Actual);
}
else
{
this.ExpectedValue = string.Join(", ", this.GetValues(expected, this.Expected));
this.ActualValue = string.Join(", ", this.GetValues(actual, this.Actual));
}
}
if (this.Expected.UrlDecode)
{
this.ExpectedValue = HttpUtility.UrlDecode(this.ExpectedValue);
}
if (this.Actual.UrlDecode)
{
this.ActualValue = HttpUtility.UrlDecode(this.ActualValue);
}
this.Success = (this.ExpectedValue == this.ActualValue);
}
public void TestAssert()
{
// Arrange
var key = fixture.Create <string>();
var value = fixture.Create <string>();
var item = new CookieAssertion {
Key = key, Value = value,
};
var arrange = new Arrange
{
HttpResponse = new HttpResponse
{
Cookies = new NameValueCollection
{
{ key, value },
{ "b", "b value" },
}
},
};
// Act
item.Assert(null, arrange);
// Assert
Assert.IsTrue(item.Success);
}
public void TestAssertWithInvalidXsd()
{
// Arrange
const string ActualHtml =
@"<Shop>
<Item>a</Item>
<Item>b</Item>
<Item>c</Item>
</Shop>";
var item = new XsdAssertion
{
Xsd =
@"<?xml version='1.0' encoding='utf-8'?>
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='Shop'>
<xs:complexType>
<xs:sequence>"
};
var actual = new Arrange {
HttpResponse = new HttpResponse {
Contents = ActualHtml, ContentType = "text/xml"
}
};
// Act
item.Assert(null, actual);
// Assert
Assert.IsFalse(item.Success);
}
/// <summary>
/// Asserts the case
/// </summary>
/// <param name="expected">expected Arrange</param>
/// <param name="actual">actual Arrange</param>
public override void Assert(Arrange expected, Arrange actual)
{
if (this.Expected.Exists.HasValue)
{
this.ExpectedValue = "Node exists: " + this.Expected.Exists;
this.ActualValue = "Node exists: " + actual.HttpResponse.ExistsNode(this.Actual.Query, this.Actual.Attribute);
}
else
{
if (!this.IsList)
{
this.ExpectedValue = this.GetValue(expected, this.Expected);
this.ActualValue = this.GetValue(actual, this.Actual);
}
else
{
this.ExpectedValue = string.Join(", ", this.GetValues(expected, this.Expected));
this.ActualValue = string.Join(", ", this.GetValues(actual, this.Actual));
}
}
if (this.Expected.UrlDecode)
{
this.ExpectedValue = HttpUtility.UrlDecode(this.ExpectedValue);
}
if (this.Actual.UrlDecode)
{
this.ActualValue = HttpUtility.UrlDecode(this.ActualValue);
}
this.Success = (this.ExpectedValue == this.ActualValue);
}
public void EditProduct_AttemptToModifyEntity_Success()
{
Arrange arr = ArrangeTests();
arr.ApiCarPartController.EditProduct(arr.CarPart.Id, arr.CarPart);
arr.Mocka.Verify(m => m.ModifyEntity(arr.CarPart.Id, arr.CarPart), Times.Once);
}
public void TestAssertWithNoItem()
{
// Arrange
var key = fixture.Create <string>();
var value = fixture.Create <string>();
var item = new HeaderAssertion {
Key = key, Value = value
};
var arrange = new Arrange
{
HttpResponse = new HttpResponse
{
Headers = new NameValueCollection
{
{ "a", "a value" },
{ "b", "b value" },
}
},
};
// Act
item.Assert(null, arrange);
// Assert
Assert.IsFalse(item.Success);
}
public void ShouldAutoResolveMissingDependeciesWithMocks()
{
var arrange = Arrange.Dependencies <IUserService, UserService>();
var userService = arrange.Resolve <IUserService>();
Assert.IsInstanceOf <UserService>(userService);
}
public void ShouldAutoResolveLogging()
{
var arrange = Arrange.Dependencies <IUserService, UserService>();
var userService = arrange.Resolve <IUserService>();
userService.Log();
}
public void For_ParameterlessCtor_ShouldNotHaveAnyDependencies()
{
// Act
var result = Arrange.For <AccountRepository>(type => new object());
// Assert
result.Dependencies.Should().BeEmpty();
}
public void For_MultipleCtorsFound_ShouldThrowInvalidOperationException()
{
// Act
Action act = () => Arrange.For <MultipleCtor>(type => new object());
// Assert
act.Should().Throw <InvalidOperationException>();
}
public void PerformCommand_ShouldFail_WhenAccessorFindsNoImages()
{
Arrange.Call(() => _imageAccessor.Get(default(ImageSource?), ImageGenre.Hardcore))
.Returns(new List <ImageMetaData>());
var actual = _service.PerformCommand(_session, Keyword.ShowHardcoreImage);
Assert.AreEqual(ErrorMessage.NoImagesFound, actual.Error.Message);
}
public void ReverStringTest()
{
Arrange arrange = new Arrange();
Console.WriteLine(arrange.list[0]);
Console.WriteLine(arrange.methods.ReverseString(arrange.list[0]));
Console.WriteLine(arrange.methods.ReverseString(arrange.list[1]));
Console.WriteLine(arrange.methods.ReverseString(arrange.list[2]));
}
public void SortIntListTests()
{
Arrange arrange = new Arrange();
arrange.methods.writelineList(arrange.listInt);
Console.WriteLine("\n");
arrange.methods.writelineList(arrange.methods.SortMethodBigtoSmall(arrange.listInt));
Console.WriteLine("\n");
arrange.methods.writelineList(arrange.methods.SortMethodSmalltoBig(arrange.listInt));
}
public void sortListTests()
{
Arrange arrange = new Arrange();
arrange.methods.writelineList(arrange.list);
Console.WriteLine("\n");
arrange.methods.writelineList(arrange.methods.SortMethodAtoZ(arrange.list));
Console.WriteLine("\n");
arrange.methods.writelineList(arrange.methods.SortMethodZtoA(arrange.list));
}
public void StringLengthTests()
{
Arrange arrange = new Arrange();
int n = arrange.methods.StringLength(arrange.list[0]);
int m = arrange.methods.StringLength(arrange.list[1]);
int o = arrange.methods.StringLength(arrange.list[2]);
int p = arrange.methods.StringLength(arrange.list[3]);
Console.WriteLine($"{n} {m} {o} {p}");
}
public void For_ConcreteType_ShouldBuild()
{
// Act
var result = Arrange.For <AccountRepository>();
// Assert
Action verify = () => result.BuildSut();
verify.Should().NotThrow();
}
public void ShouldResolveClassWithInMemoryCacheDependency()
{
var arrange = Arrange.Dependencies <IUserRepository, UserRepository>(dependencies =>
{
dependencies.UseDbContext <TestDbContext>();
});
var userRepository = arrange.Resolve <IUserRepository>();
Assert.IsInstanceOf <UserRepository>(userRepository);
}
public void ShouldResolveMultipleImplementationsFromAssembly()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseImplementations <IUserFactory>(typeof(IUserFactory).Assembly);
});
var providers = arrange.Resolve <IUserFactory[]>();
Assert.AreEqual(2, providers.Length);
}
public void ShouldResolveUseImplementationWhenConstructed()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseImplementation <IUserFactory, AdminUserFactory>(new AdminUserFactory());
});
var userService = arrange.Resolve <IUserFactory>();
Assert.IsInstanceOf <AdminUserFactory>(userService);
}
public void ShouldResolveUseImplementation()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseImplementation <IUserService, UserService>();
});
var userService = arrange.Resolve <IUserService>();
Assert.IsInstanceOf <UserService>(userService);
}
public void Sut_Func_Action_ShouldReturnDependency()
{
// Arrange
var dependency = new AccountRepository();
// Act
var result = Arrange.Sut <AccountService>(type => dependency, action => { });
// Assert
result.AccountRepository.Should().Be(dependency);
}
public void For_CtorWithParameters_ShouldReturnFluentArrangeObjectWithDependency()
{
// Arrange
var dependency = new AccountRepository();
// Act
var result = Arrange.For <AccountService>(type => dependency);
// Assert
result.Dependencies.Values.Should().SatisfyRespectively(first => first.Should().Be(dependency));
}
public void Sut_Action_ShouldInvokeAction()
{
// Arrange
var invoked = false;
// Act
_ = Arrange.Sut <AccountService>(_ => invoked = true);
// Assert
invoked.Should().BeTrue();
}
public void ShouldUseDbContext()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseDbContext <TestDbContext>();
});
var testContext = arrange.Resolve <TestDbContext>();
Assert.IsInstanceOf <TestDbContext>(testContext);
}
public void CreateMock_InterfaceType_ShouldReturnObjectOfTypeObjectProxy()
{
// Arrange
var type = typeof(IAccountRepository);
// Act
var result = Arrange.CreateMock(type);
// Assert
result.GetType().FullName.Should().Be("Castle.Proxies.ObjectProxy");
}
public void ShouldAddEntity()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseEntity <Company, TestDbContext>(new Company());
});
var db = arrange.Resolve <TestDbContext>();
var company = db.Company.FirstOrDefault();
Assert.AreEqual(1, company.Id);
}
public void Sut_Func_Action_ShouldInvokeAction()
{
// Arrange
var dependency = new AccountRepository();
var invoked = false;
// Act
_ = Arrange.Sut <AccountService>(type => dependency, action => invoked = true);
// Assert
invoked.Should().BeTrue();
}
public void ShouldResolveMultipleImplementations()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseImplementation <IUserFactory, AdminUserFactory>();
dependencies.UseImplementation <IUserFactory, BasicUserFactory>();
});
var providers = arrange.Resolve <IUserFactory[]>();
Assert.AreEqual(2, providers.Length);
}
public void ShouldNotCreateMultipleEntitesOnMultipleResolves()
{
var arrange = Arrange.Dependencies <IUserService, UserService>(dependencies =>
{
dependencies.UseEntity <User, TestDbContext>((user) => user.SetName("Test name"));
});
var service = arrange.Resolve <IUserService>();
var db = arrange.Resolve <TestDbContext>();
Assert.AreEqual(1, db.User.Count());
}
/// <summary>
/// Gets Values
/// </summary>
/// <param name="arrange">arrange parameter</param>
/// <param name="assertionItem">assertionItem parameter</param>
/// <returns>value from arrange</returns>
protected override IEnumerable<string> GetValues(Arrange arrange, ContentAssertionItem assertionItem)
{
var values = base.GetValues(arrange, assertionItem);
var list = new List<string>();
foreach (var value in values)
{
list.Add(GetDateTimeString(value, assertionItem.Format, assertionItem.FormatCulture));
}
return list;
}
public void ShouldCreateEntity()
{
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseEntity <User, TestDbContext>((user) => user.SetName("Test name"));
});
var db = arrange.Resolve <TestDbContext>();
var user = db.User.FirstOrDefault();
Assert.IsNotNull(user);
}
/// <summary>
/// Assert the case
/// </summary>
/// <param name="expected">expected Arrange</param>
/// <param name="actual">actual Arrange</param>
public override void Assert(Arrange expected, Arrange actual)
{
this.ExpectedValue = this.Value;
var match = Regex.Match(actual.HttpResponse.Uri.OriginalString, ".*://[^/]*(.*)", RegexOptions.None);
if (match.Success)
{
ActualValue = match.Groups[1].Value;
if (string.IsNullOrWhiteSpace(ActualValue))
{
ActualValue = "/";
}
}
this.Success = this.ExpectedValue == this.ActualValue;
}
/// <summary>
/// Asserts the case
/// </summary>
/// <param name="expected">expected Arrange</param>
/// <param name="actual">actual Arrange</param>
public override void Assert(Arrange expected, Arrange actual)
{
if (!this.IsList)
{
this.ExpectedValue = GetValue(expected, this.Expected);
this.ActualValue = GetValue(actual, this.Actual);
}
else
{
this.ExpectedValue = string.Join(", ", GetValues(expected, this.Expected));
this.ActualValue = string.Join(", ", GetValues(actual, this.Actual));
}
this.Success = this.ExpectedValue == this.ActualValue;
}
/// <summary>
/// Asserts
/// </summary>
/// <param name="expected">expected parameter</param>
/// <param name="actual">actual parameter</param>
public override void Assert(Arrange expected, Arrange actual)
{
string text;
try
{
actual.HttpResponse.DocumentParser.TestSchemaWithXsd(this.Xsd);
text = null;
}
catch (Exception ex)
{
text = ex.ToString();
}
this.ExpectedValue = "True";
this.ActualValue = ((text == null) ? "True" : string.Format("Exception=<{0}>", text));
this.Success = (this.ExpectedValue == this.ActualValue);
}
/// <summary> /// Assert the case /// </summary> /// <param name="expected">expected Arrange</param> /// <param name="actual">actual Arrange</param> public abstract void Assert(Arrange expected, Arrange actual);
/// <summary>
/// Gets Value
/// </summary>
/// <param name="arrange">arrange parameter</param>
/// <param name="assertionItem">assertionItem parameter</param>
/// <returns>value from arrange</returns>
protected virtual string GetValue(Arrange arrange, ContentAssertionItem assertionItem)
{
if (assertionItem.Value != null)
{
return assertionItem.Value;
}
var value = arrange.HttpResponse.GetDocumentValue(assertionItem.Query, assertionItem.Attribute);
if (assertionItem.Pattern != null)
{
return TextAssertion.Match(value, assertionItem.Pattern);
}
return value;
}
/// <summary>
/// Gets Value
/// </summary>
/// <param name="arrange">arrange parameter</param>
/// <param name="assertionItem">assertionItem parameter</param>
/// <returns>value from arrange</returns>
protected override string GetValue(Arrange arrange, ContentAssertionItem assertionItem)
{
var value = base.GetValue(arrange, assertionItem);
return GetDateTimeString(value, assertionItem.Format, assertionItem.FormatCulture);
}
/// <summary>
/// Asserts the case
/// </summary>
/// <param name="expected">expected Arrange</param>
/// <param name="actual">actual Arrange</param>
public override void Assert(Arrange expected, Arrange actual)
{
this.ExpectedValue = this.Value;
this.ActualValue = actual.HttpResponse.Headers[this.Key];
this.Success = this.ExpectedValue == this.ActualValue;
}
/// <summary>
/// Gets Values
/// </summary>
/// <param name="arrange">arrange parameter</param>
/// <param name="assertionItem">assertionItem parameter</param>
/// <returns>value from arrange</returns>
protected virtual IEnumerable<string> GetValues(Arrange arrange, ContentAssertionItem assertionItem)
{
if (assertionItem.Value != null)
{
throw new NotImplementedException("Static value test for list is not supported.");
}
var values = arrange.HttpResponse.GetDocumentValues(assertionItem.Query, assertionItem.Attribute);
if (assertionItem.Pattern != null)
{
var list = new List<string>();
foreach (var value in values)
{
list.Add(Match(value, assertionItem.Pattern));
}
return list;
}
return values;
}
/// <summary>
/// Asserts the case
/// </summary>
/// <param name="expected">expected Arrange</param>
/// <param name="actual">actual Arrange</param>
public override void Assert(Arrange expected, Arrange actual)
{
this.ExpectedValue = this.Value;
this.ActualValue = ((int)actual.HttpResponse.StatusCode).ToString(CultureInfo.InvariantCulture);
this.Success = this.ExpectedValue == this.ActualValue;
}
