From e55e688dc7432a71adf1b80025da0e8fb76c5442 Mon Sep 17 00:00:00 2001 From: "shannon@ShandemVaio" Date: Tue, 31 Jul 2012 00:02:27 +0600 Subject: [PATCH] Added unit test for ContentStore, added object extensions and supporting classes from v5, added RhinoMocks to the test project and httpcontext factory from v5 unit tests to be used in our v4 ones. --- src/Umbraco.Core/Attempt.cs | 66 + .../CustomBooleanTypeConverter.cs | 32 + src/Umbraco.Core/ObjectExtensions.cs | 376 ++ src/Umbraco.Core/StringExtensions.cs | 45 + src/Umbraco.Core/TypeHelper.cs | 2 +- src/Umbraco.Core/Umbraco.Core.csproj | 4 + src/Umbraco.Core/XmlExtensions.cs | 30 + src/Umbraco.Core/XmlHelper.cs | 3 +- ...> AsynchronousRollingFileAppenderTests.cs} | 3 +- src/Umbraco.Tests/ContentStoreTests.cs | 75 + .../TestHelpers/FakeHttpContextFactory.cs | 96 + .../{ => TestHelpers}/TestHelper.cs | 2 +- src/Umbraco.Tests/TypeFinderTests.cs | 1 + src/Umbraco.Tests/Umbraco.Tests.csproj | 9 +- src/Umbraco.Tests/packages.config | 1 + src/Umbraco.Web/Properties/AssemblyInfo.cs | 2 + src/Umbraco.Web/Routing/DefaultRoutesCache.cs | 38 +- src/Umbraco.Web/UmbracoContext.cs | 48 +- .../RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg | Bin 0 -> 193870 bytes .../RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll | Bin 0 -> 317952 bytes .../RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml | 5624 +++++++++++++++++ src/umbraco.businesslogic/StateHelper.cs | 110 +- 22 files changed, 6516 insertions(+), 51 deletions(-) create mode 100644 src/Umbraco.Core/Attempt.cs create mode 100644 src/Umbraco.Core/CustomBooleanTypeConverter.cs create mode 100644 src/Umbraco.Core/ObjectExtensions.cs create mode 100644 src/Umbraco.Core/XmlExtensions.cs rename src/Umbraco.Tests/{AsynchronousRollingFileAppenderTest.cs => AsynchronousRollingFileAppenderTests.cs} (94%) create mode 100644 src/Umbraco.Tests/ContentStoreTests.cs create mode 100644 src/Umbraco.Tests/TestHelpers/FakeHttpContextFactory.cs rename src/Umbraco.Tests/{ => TestHelpers}/TestHelper.cs (93%) create mode 100644 src/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg create mode 100644 src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll create mode 100644 src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml diff --git a/src/Umbraco.Core/Attempt.cs b/src/Umbraco.Core/Attempt.cs new file mode 100644 index 0000000000..927f68d7a4 --- /dev/null +++ b/src/Umbraco.Core/Attempt.cs @@ -0,0 +1,66 @@ +using System; + +namespace Umbraco.Core +{ + /// + /// Represents the result of an operation attempt + /// + /// + /// + [Serializable] + public struct Attempt + { + private readonly bool _success; + private readonly T _result; + private readonly Exception _error; + + /// + /// Gets a value indicating whether this represents a successful operation. + /// + /// + public bool Success + { + get { return _success; } + } + + /// + /// Gets the error associated with an unsuccessful attempt. + /// + /// The error. + public Exception Error { get { return _error; } } + + /// + /// Gets the parse result. + /// + /// + public T Result + { + get { return _result; } + } + + /// + /// Represents an unsuccessful parse operation + /// + public static readonly Attempt False; + + /// + /// Initializes a new instance of the struct. + /// + /// If set to true this tuple represents a successful parse result. + /// The parse result. + /// + public Attempt(bool success, T result) + { + _success = success; + _result = result; + _error = null; + } + + public Attempt(Exception error) + { + _success = false; + _result = default(T); + _error = error; + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/CustomBooleanTypeConverter.cs b/src/Umbraco.Core/CustomBooleanTypeConverter.cs new file mode 100644 index 0000000000..b7b30d1fa1 --- /dev/null +++ b/src/Umbraco.Core/CustomBooleanTypeConverter.cs @@ -0,0 +1,32 @@ +using System; +using System.ComponentModel; + +namespace Umbraco.Core +{ + /// + /// Allows for converting string representations of 0 and 1 to boolean + /// + internal class CustomBooleanTypeConverter : BooleanConverter + { + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + { + return true; + } + return base.CanConvertFrom(context, sourceType); + } + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) + { + if (value is string) + { + var str = (string)value; + if (str == "1") return true; + if (str == "0") return false; + } + + return base.ConvertFrom(context, culture, value); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/ObjectExtensions.cs b/src/Umbraco.Core/ObjectExtensions.cs new file mode 100644 index 0000000000..e19335aba3 --- /dev/null +++ b/src/Umbraco.Core/ObjectExtensions.cs @@ -0,0 +1,376 @@ +using System; +using System.Collections; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; +using System.Linq.Expressions; +using System.Reflection; +using System.Runtime.Serialization; +using System.Runtime.Serialization.Formatters.Binary; +using System.Security; +using System.Text; +using System.Xml; + +namespace Umbraco.Core +{ + internal static class ObjectExtensions + { + //private static readonly ConcurrentDictionary> ObjectFactoryCache = new ConcurrentDictionary>(); + + public static IEnumerable AsEnumerableOfOne(this T input) + { + return Enumerable.Repeat(input, 1); + } + + public static void DisposeIfDisposable(this object input) + { + var disposable = input as IDisposable; + if (disposable != null) disposable.Dispose(); + } + + /// + /// Provides a shortcut way of safely casting an input when you cannot guarantee the is an instance type (i.e., when the C# AS keyword is not applicable) + /// + /// + /// The input. + /// + public static T SafeCast(this object input) + { + if (ReferenceEquals(null, input) || ReferenceEquals(default(T), input)) return default(T); + if (input is T) return (T)input; + return default(T); + } + + /// + /// Tries to convert the input object to the output type using TypeConverters + /// + /// + /// + /// + public static Attempt TryConvertTo(this object input) + { + var result = TryConvertTo(input, typeof(T)); + return !result.Success ? Attempt.False : new Attempt(true, (T)result.Result); + } + + /// + /// Tries to convert the input object to the output type using TypeConverters. If the destination type is a superclass of the input type, + /// if will use . + /// + /// The input. + /// Type of the destination. + /// + public static Attempt TryConvertTo(this object input, Type destinationType) + { + if (input == null) return Attempt.False; + + if (destinationType == typeof(object)) return new Attempt(true, input); + + if (input.GetType() == destinationType) return new Attempt(true, input); + + if (!destinationType.IsGenericType || destinationType.GetGenericTypeDefinition() != typeof(Nullable<>)) + { + if (TypeHelper.IsTypeAssignableFrom(destinationType, input.GetType()) + && TypeHelper.IsTypeAssignableFrom(input)) + { + var casted = Convert.ChangeType(input, destinationType); + return new Attempt(true, casted); + } + } + + var inputConverter = TypeDescriptor.GetConverter(input); + if (inputConverter != null) + { + if (inputConverter.CanConvertTo(destinationType)) + { + return new Attempt(true, inputConverter.ConvertTo(input, destinationType)); + } + } + + if (destinationType == typeof(bool)) + { + var boolConverter = new CustomBooleanTypeConverter(); + if (boolConverter.CanConvertFrom(input.GetType())) + { + return new Attempt(true, boolConverter.ConvertFrom(input)); + } + } + + var outputConverter = TypeDescriptor.GetConverter(destinationType); + if (outputConverter != null) + { + if (outputConverter.CanConvertFrom(input.GetType())) + { + return new Attempt(true, outputConverter.ConvertFrom(input)); + } + } + + try + { + if (TypeHelper.IsTypeAssignableFrom(input)) + { + var casted = Convert.ChangeType(input, destinationType); + return new Attempt(true, casted); + } + } + catch (Exception) + { + /* Swallow */ + } + + return Attempt.False; + } + + public static void CheckThrowObjectDisposed(this IDisposable disposable, bool isDisposed, string objectname) + { + //TODO: Localise this exception + if (isDisposed) + throw new ObjectDisposedException(objectname); + } + + //public enum PropertyNamesCaseType + //{ + // CamelCase, + // CaseInsensitive + //} + + ///// + ///// Convert an object to a JSON string with camelCase formatting + ///// + ///// + ///// + //public static string ToJsonString(this object obj) + //{ + // return obj.ToJsonString(PropertyNamesCaseType.CamelCase); + //} + + ///// + ///// Convert an object to a JSON string with the specified formatting + ///// + ///// The obj. + ///// Type of the property names case. + ///// + //public static string ToJsonString(this object obj, PropertyNamesCaseType propertyNamesCaseType) + //{ + // var type = obj.GetType(); + // var dateTimeStyle = "yyyy-MM-dd HH:mm:ss"; + + // if (type.IsPrimitive || typeof(string).IsAssignableFrom(type)) + // { + // return obj.ToString(); + // } + + // if (typeof(DateTime).IsAssignableFrom(type) || typeof(DateTimeOffset).IsAssignableFrom(type)) + // { + // return Convert.ToDateTime(obj).ToString(dateTimeStyle); + // } + + // var serializer = new JsonSerializer(); + + // switch (propertyNamesCaseType) + // { + // case PropertyNamesCaseType.CamelCase: + // serializer.ContractResolver = new CamelCasePropertyNamesContractResolver(); + // break; + // } + + // var dateTimeConverter = new IsoDateTimeConverter + // { + // DateTimeStyles = System.Globalization.DateTimeStyles.None, + // DateTimeFormat = dateTimeStyle + // }; + + // if (typeof(IDictionary).IsAssignableFrom(type)) + // { + // return JObject.FromObject(obj, serializer).ToString(Formatting.None, dateTimeConverter); + // } + + // if (type.IsArray || (typeof(IEnumerable).IsAssignableFrom(type))) + // { + // return JArray.FromObject(obj, serializer).ToString(Formatting.None, dateTimeConverter); + // } + + // return JObject.FromObject(obj, serializer).ToString(Formatting.None, dateTimeConverter); + //} + + /// + /// Converts an object into a dictionary + /// + /// + /// + /// + /// + /// + /// + public static IDictionary ToDictionary(this T o, + params Expression>[] ignoreProperties) + { + return o.ToDictionary(ignoreProperties.Select(e => o.GetPropertyInfo(e)).Select(propInfo => propInfo.Name).ToArray()); + } + + /// + /// Turns object into dictionary + /// + /// + /// Properties to ignore + /// + public static IDictionary ToDictionary(this object o, params string[] ignoreProperties) + { + if (o != null) + { + var props = TypeDescriptor.GetProperties(o); + var d = new Dictionary(); + foreach (var prop in props.Cast().Where(x => !ignoreProperties.Contains(x.Name))) + { + var val = prop.GetValue(o); + if (val != null) + { + d.Add(prop.Name, (TVal)val); + } + } + return d; + } + return new Dictionary(); + } + + public static string ToDebugString(this object obj, int levels = 0) + { + if (obj == null) return "{null}"; + try + { + if (obj is string) + { + return "\"{0}\"".InvariantFormat(obj); + } + if (obj is int || obj is Int16 || obj is Int64 || obj is double || obj is bool || obj is int? || obj is Int16? || obj is Int64? || obj is double? || obj is bool?) + { + return "{0}".InvariantFormat(obj); + } + if (obj is Enum) + { + return "[{0}]".InvariantFormat(obj); + } + if (obj is IEnumerable) + { + var enumerable = (obj as IEnumerable); + + var items = (from object enumItem in enumerable let value = GetEnumPropertyDebugString(enumItem, levels) where value != null select value).Take(10).ToList(); + + return items.Count() > 0 + ? "{{ {0} }}".InvariantFormat(String.Join(", ", items)) + : null; + } + + var props = obj.GetType().GetProperties(); + if ((props.Count() == 2) && props[0].Name == "Key" && props[1].Name == "Value" && levels > -2) + { + try + { + var key = props[0].GetValue(obj, null) as string; + var value = props[1].GetValue(obj, null).ToDebugString(levels - 1); + return "{0}={1}".InvariantFormat(key, value); + } + catch (Exception) + { + return "[KeyValuePropertyException]"; + } + } + if (levels > -1) + { + var items = + from propertyInfo in props + let value = GetPropertyDebugString(propertyInfo, obj, levels) + where value != null + select "{0}={1}".InvariantFormat(propertyInfo.Name, value); + + return items.Count() > 0 + ? "[{0}]:{{ {1} }}".InvariantFormat(obj.GetType().Name, String.Join(", ", items)) + : null; + } + } + catch (Exception ex) + { + return "[Exception:{0}]".InvariantFormat(ex.Message); + } + return null; + } + + + /// + /// Attempts to serialize the value to an XmlString using ToXmlString + /// + /// + /// + /// + public static Attempt TryConvertToXmlString(this object value, Type type) + { + try + { + var output = value.ToXmlString(type); + return new Attempt(true, output); + } + catch (NotSupportedException ex) + { + return new Attempt(ex); + } + } + + /// + /// Returns an XmlSerialized safe string representation for the value + /// + /// + /// The Type can only be a primitive type or Guid and byte[] otherwise an exception is thrown + /// + public static string ToXmlString(this object value, Type type) + { + if (type == typeof(string)) return ((string)value).IsNullOrWhiteSpace() ? "" : (string)value; + if (type == typeof(bool)) return XmlConvert.ToString((bool)value); + if (type == typeof(byte)) return XmlConvert.ToString((byte)value); + if (type == typeof(char)) return XmlConvert.ToString((char)value); + if (type == typeof(DateTime)) return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.RoundtripKind); + if (type == typeof(DateTimeOffset)) return XmlConvert.ToString((DateTimeOffset)value); + if (type == typeof(decimal)) return XmlConvert.ToString((decimal)value); + if (type == typeof(double)) return XmlConvert.ToString((double)value); + if (type == typeof(float)) return XmlConvert.ToString((float)value); + if (type == typeof(Guid)) return XmlConvert.ToString((Guid)value); + if (type == typeof(int)) return XmlConvert.ToString((int)value); + if (type == typeof(long)) return XmlConvert.ToString((long)value); + if (type == typeof(sbyte)) return XmlConvert.ToString((sbyte)value); + if (type == typeof(short)) return XmlConvert.ToString((short)value); + if (type == typeof(TimeSpan)) return XmlConvert.ToString((TimeSpan)value); + if (type == typeof(bool)) return XmlConvert.ToString((bool)value); + if (type == typeof(uint)) return XmlConvert.ToString((uint)value); + if (type == typeof(ulong)) return XmlConvert.ToString((ulong)value); + if (type == typeof(ushort)) return XmlConvert.ToString((ushort)value); + + throw new NotSupportedException("Cannot convert type " + type.FullName + " to a string using ToXmlString as it is not supported by XmlConvert"); + } + + private static string GetEnumPropertyDebugString(object enumItem, int levels) + { + try + { + return enumItem.ToDebugString(levels - 1); + } + catch (Exception) + { + return "[GetEnumPartException]"; + } + } + + private static string GetPropertyDebugString(PropertyInfo propertyInfo, object obj, int levels) + { + try + { + return propertyInfo.GetValue(obj, null).ToDebugString(levels - 1); + } + catch (Exception) + { + return "[GetPropertyValueException]"; + } + } + + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/StringExtensions.cs b/src/Umbraco.Core/StringExtensions.cs index 0c2e227317..634f029655 100644 --- a/src/Umbraco.Core/StringExtensions.cs +++ b/src/Umbraco.Core/StringExtensions.cs @@ -12,6 +12,7 @@ using System.Web; namespace Umbraco.Core { + /// /// String extension methods /// @@ -29,6 +30,50 @@ namespace Umbraco.Core return value.TrimEnd(forRemoving).TrimStart(forRemoving); } + public static string EncodeJsString(this string s) + { + var sb = new StringBuilder(); + foreach (var c in s) + { + switch (c) + { + case '\"': + sb.Append("\\\""); + break; + case '\\': + sb.Append("\\\\"); + break; + case '\b': + sb.Append("\\b"); + break; + case '\f': + sb.Append("\\f"); + break; + case '\n': + sb.Append("\\n"); + break; + case '\r': + sb.Append("\\r"); + break; + case '\t': + sb.Append("\\t"); + break; + default: + int i = (int)c; + if (i < 32 || i > 127) + { + sb.AppendFormat("\\u{0:X04}", i); + } + else + { + sb.Append(c); + } + break; + } + } + return sb.ToString(); + } + public static string TrimEnd(this string value, string forRemoving) { if (string.IsNullOrEmpty(value)) return value; diff --git a/src/Umbraco.Core/TypeHelper.cs b/src/Umbraco.Core/TypeHelper.cs index 231c5b3b4c..f61fda920a 100644 --- a/src/Umbraco.Core/TypeHelper.cs +++ b/src/Umbraco.Core/TypeHelper.cs @@ -9,7 +9,7 @@ namespace Umbraco.Core /// A utility class for type checking, this provides internal caching so that calls to these methods will be faster /// than doing a manual type check in c# /// - public static class TypeHelper + internal static class TypeHelper { private static readonly ConcurrentDictionary, bool> TypeCheckCache = new ConcurrentDictionary, bool>(); private static readonly ConcurrentDictionary ValueTypeCache = new ConcurrentDictionary(); diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index a972e320fe..3106a9d6b3 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -49,8 +49,10 @@ Properties\SolutionInfo.cs + + @@ -63,6 +65,7 @@ + @@ -87,6 +90,7 @@ + diff --git a/src/Umbraco.Core/XmlExtensions.cs b/src/Umbraco.Core/XmlExtensions.cs new file mode 100644 index 0000000000..ab526f6532 --- /dev/null +++ b/src/Umbraco.Core/XmlExtensions.cs @@ -0,0 +1,30 @@ +using System; +using System.Xml; + +namespace Umbraco.Core +{ + + /// + /// Extension methods for xml objects + /// + internal static class XmlExtensions + { + + public static T AttributeValue(this XmlNode xml, string attributeName) + { + if (xml == null) throw new ArgumentNullException("xml"); + if (xml.Attributes == null) return default(T); + + if (xml.Attributes[attributeName] == null) + return default(T); + + var val = xml.Attributes[attributeName].Value; + var result = val.TryConvertTo(); + if (result.Success) + return result.Result; + + return default(T); + } + + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/XmlHelper.cs b/src/Umbraco.Core/XmlHelper.cs index eb20fb1595..b30e502672 100644 --- a/src/Umbraco.Core/XmlHelper.cs +++ b/src/Umbraco.Core/XmlHelper.cs @@ -9,7 +9,8 @@ namespace Umbraco.Core /// internal class XmlHelper { - /// + + /// /// Imports a XML node from text. /// /// The text. diff --git a/src/Umbraco.Tests/AsynchronousRollingFileAppenderTest.cs b/src/Umbraco.Tests/AsynchronousRollingFileAppenderTests.cs similarity index 94% rename from src/Umbraco.Tests/AsynchronousRollingFileAppenderTest.cs rename to src/Umbraco.Tests/AsynchronousRollingFileAppenderTests.cs index 7cf976178a..9e49bb3290 100644 --- a/src/Umbraco.Tests/AsynchronousRollingFileAppenderTest.cs +++ b/src/Umbraco.Tests/AsynchronousRollingFileAppenderTests.cs @@ -6,6 +6,7 @@ using System.Threading; using NUnit.Framework; using Umbraco.Core; using Umbraco.Core.Logging; +using Umbraco.Tests.TestHelpers; using log4net; using log4net.Config; using log4net.Core; @@ -15,7 +16,7 @@ using log4net.Repository; namespace Umbraco.Tests { [TestFixture] - public class AsynchronousRollingFileAppenderTest + public class AsynchronousRollingFileAppenderTests { private const string ErrorMessage = "TEST ERROR MESSAGE"; private string _fileFolderPath = @"c:\LogTesting\"; diff --git a/src/Umbraco.Tests/ContentStoreTests.cs b/src/Umbraco.Tests/ContentStoreTests.cs new file mode 100644 index 0000000000..331cd5036d --- /dev/null +++ b/src/Umbraco.Tests/ContentStoreTests.cs @@ -0,0 +1,75 @@ +using System.Xml; +using NUnit.Framework; +using Umbraco.Core; +using Umbraco.Tests.TestHelpers; +using Umbraco.Web; +using Umbraco.Web.Routing; +using umbraco.BusinessLogic; + +namespace Umbraco.Tests +{ + [TestFixture] + public class ContentStoreTests + { + private FakeHttpContextFactory _httpContextFactory; + private UmbracoContext _umbracoContext; + private ContentStore _contentStore; + + [SetUp] + public void SetUp() + { + _httpContextFactory = new FakeHttpContextFactory("~/Home"); + //ensure the StateHelper is using our custom context + StateHelper.HttpContext = _httpContextFactory.HttpContext; + + _umbracoContext = new UmbracoContext(_httpContextFactory.HttpContext, + new ApplicationContext(), + new DefaultRoutesCache(false)); + + _umbracoContext.GetXmlDelegate = () => + { + var xDoc = new XmlDocument(); + + //create a custom xml structure to return + + xDoc.LoadXml(@" + + +]> + + + + + + + + + + + + +"); + //return the custom x doc + return xDoc; + }; + + _contentStore = new ContentStore(_umbracoContext); + + } + + [TearDown] + public void TearDown() + { + + } + + [Test] + public void Get_Node_By_Route() + { + var result = _contentStore.GetNodeByRoute("/"); + Assert.IsNotNull(result); + Assert.AreEqual(1046, result.AttributeValue("id")); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/TestHelpers/FakeHttpContextFactory.cs b/src/Umbraco.Tests/TestHelpers/FakeHttpContextFactory.cs new file mode 100644 index 0000000000..572157ff98 --- /dev/null +++ b/src/Umbraco.Tests/TestHelpers/FakeHttpContextFactory.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections.Generic; +using System.Collections.Specialized; +using System.Linq; +using System.Security; +using System.Text; +using System.Web; +using System.Web.Routing; +using Rhino.Mocks; + +namespace Umbraco.Tests.TestHelpers +{ + /// + /// Creates a mock http context with supporting other contexts to test against + /// + public class FakeHttpContextFactory + { + + [SecuritySafeCritical] + public FakeHttpContextFactory(Uri fullUrl) + { + CreateContext(fullUrl); + } + + [SecuritySafeCritical] + public FakeHttpContextFactory(string path) + { + CreateContext(new Uri("http://mysite" + VirtualPathUtility.ToAbsolute(path, "/"))); + } + + [SecuritySafeCritical] + public FakeHttpContextFactory(string path, RouteData routeData) + { + CreateContext(new Uri("http://mysite" + VirtualPathUtility.ToAbsolute(path, "/")), routeData); + } + + public HttpContextBase HttpContext { get; private set; } + public RequestContext RequestContext { get; private set; } + + /// + /// Mocks the http context to test against + /// + /// + /// + /// + private void CreateContext(Uri fullUrl, RouteData routeData = null) + { + //Request context + + RequestContext = MockRepository.GenerateMock(); + + //Request + + var request = MockRepository.GenerateMock(); + request.Stub(x => x.AppRelativeCurrentExecutionFilePath).Return("~" + fullUrl.AbsolutePath); + request.Stub(x => x.PathInfo).Return(string.Empty); + request.Stub(x => x.RawUrl).Return(VirtualPathUtility.ToAbsolute("~" + fullUrl.AbsolutePath, "/")); + request.Stub(x => x.RequestContext).Return(RequestContext); + request.Stub(x => x.Url).Return(fullUrl); + request.Stub(x => x.ApplicationPath).Return("/"); + request.Stub(x => x.Cookies).Return(new HttpCookieCollection()); + request.Stub(x => x.ServerVariables).Return(new NameValueCollection()); + + //Cache + var cache = MockRepository.GenerateMock(); + + //Response + //var response = new FakeHttpResponse(); + var response = MockRepository.GenerateMock(); + response.Stub(x => x.ApplyAppPathModifier(null)).IgnoreArguments().Do(new Func(appPath => appPath)); + response.Stub(x => x.Cache).Return(cache); + + //Server + + var server = MockRepository.GenerateStub(); + server.Stub(x => x.MapPath(Arg.Is.Anything)).Return(Environment.CurrentDirectory); + + //HTTP Context + + HttpContext = MockRepository.GenerateMock(); + HttpContext.Stub(x => x.Cache).Return(HttpRuntime.Cache); + HttpContext.Stub(x => x.Items).Return(new Dictionary()); + HttpContext.Stub(x => x.Request).Return(request); + HttpContext.Stub(x => x.Server).Return(server); + HttpContext.Stub(x => x.Response).Return(response); + + RequestContext.Stub(x => x.HttpContext).Return(HttpContext); + + if (routeData != null) + { + RequestContext.Stub(x => x.RouteData).Return(routeData); + } + } + + } +} diff --git a/src/Umbraco.Tests/TestHelper.cs b/src/Umbraco.Tests/TestHelpers/TestHelper.cs similarity index 93% rename from src/Umbraco.Tests/TestHelper.cs rename to src/Umbraco.Tests/TestHelpers/TestHelper.cs index fce91d4d5e..69b2a52cf4 100644 --- a/src/Umbraco.Tests/TestHelper.cs +++ b/src/Umbraco.Tests/TestHelpers/TestHelper.cs @@ -2,7 +2,7 @@ using System; using System.IO; using System.Reflection; -namespace Umbraco.Tests +namespace Umbraco.Tests.TestHelpers { /// /// Common helper properties and methods useful to testing diff --git a/src/Umbraco.Tests/TypeFinderTests.cs b/src/Umbraco.Tests/TypeFinderTests.cs index 2c61502a78..82c809e030 100644 --- a/src/Umbraco.Tests/TypeFinderTests.cs +++ b/src/Umbraco.Tests/TypeFinderTests.cs @@ -8,6 +8,7 @@ using SqlCE4Umbraco; using Umbraco.Core; using Umbraco.Tests; using Umbraco.Tests.PartialTrust; +using Umbraco.Tests.TestHelpers; using umbraco; using umbraco.DataLayer; using umbraco.MacroEngines; diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index e23c094eba..ceffd7db47 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -37,6 +37,9 @@ ..\packages\NUnit.2.6.0.12054\lib\nunit.framework.dll + + ..\packages\RhinoMocks.3.6.1\lib\net\Rhino.Mocks.dll + @@ -49,10 +52,11 @@ - + + @@ -60,7 +64,7 @@ - + @@ -71,6 +75,7 @@ + diff --git a/src/Umbraco.Tests/packages.config b/src/Umbraco.Tests/packages.config index 6c2c554293..ea5bd3ccda 100644 --- a/src/Umbraco.Tests/packages.config +++ b/src/Umbraco.Tests/packages.config @@ -2,4 +2,5 @@ + \ No newline at end of file diff --git a/src/Umbraco.Web/Properties/AssemblyInfo.cs b/src/Umbraco.Web/Properties/AssemblyInfo.cs index c593bb557f..3712c4a64e 100644 --- a/src/Umbraco.Web/Properties/AssemblyInfo.cs +++ b/src/Umbraco.Web/Properties/AssemblyInfo.cs @@ -14,3 +14,5 @@ using System.Runtime.CompilerServices; //tg forcing .NET 2.0 security rules, since otherwise it wasn't possible to run in medium trust //(got an inheritance security rules violated by type error) [assembly: System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)] + +[assembly: InternalsVisibleTo("Umbraco.Tests")] diff --git a/src/Umbraco.Web/Routing/DefaultRoutesCache.cs b/src/Umbraco.Web/Routing/DefaultRoutesCache.cs index 55a2c08e75..d2b37f2a3a 100644 --- a/src/Umbraco.Web/Routing/DefaultRoutesCache.cs +++ b/src/Umbraco.Web/Routing/DefaultRoutesCache.cs @@ -17,23 +17,33 @@ namespace Umbraco.Web.Routing /// /// Initializes a new instance of the class. /// - public DefaultRoutesCache() + public DefaultRoutesCache() : this(true) { - Clear(); - - //FIXME: - // - // here we must register handlers to clear the cache when content changes - // this was done by presentation.library, which cleared everything when content changed - // but really, we should do some partial refreshes - - // these are the two events that were used by presentation.library - // are they enough? - - global::umbraco.content.AfterRefreshContent += (sender, e) => Clear(); - global::umbraco.content.AfterUpdateDocumentCache += (sender, e) => Clear(); + } + internal DefaultRoutesCache(bool bindToEvents) + { + Clear(); + + if (bindToEvents) + { + //FIXME: + // + // here we must register handlers to clear the cache when content changes + // this was done by presentation.library, which cleared everything when content changed + // but really, we should do some partial refreshes + + // these are the two events that were used by presentation.library + // are they enough? + + global::umbraco.content.AfterRefreshContent += (sender, e) => Clear(); + global::umbraco.content.AfterUpdateDocumentCache += (sender, e) => Clear(); + } + + + } + /// /// Stores a route for a node. /// diff --git a/src/Umbraco.Web/UmbracoContext.cs b/src/Umbraco.Web/UmbracoContext.cs index 806ef7a438..f96497f45a 100644 --- a/src/Umbraco.Web/UmbracoContext.cs +++ b/src/Umbraco.Web/UmbracoContext.cs @@ -142,6 +142,40 @@ namespace Umbraco.Web /// That is, lowercase, no trailing slash after path, no .aspx... internal Uri UmbracoUrl { get; set; } + private Func _xmlDelegate; + + /// + /// Gets/sets the delegate used to retreive the Xml content, generally the setter is only used for unit tests + /// and by default if it is not set will use the standard delegate which ONLY works when in the context an Http Request + /// + /// + /// If not defined, we will use the standard delegate which ONLY works when in the context an Http Request + /// mostly because the 'content' object heavily relies on HttpContext, SQL connections and a bunch of other stuff + /// that when run inside of a unit test fails. + /// + internal Func GetXmlDelegate + { + get + { + return _xmlDelegate ?? (_xmlDelegate = () => + { + if (InPreviewMode) + { + if (_previewContent == null) + { + _previewContent = new PreviewContent(UmbracoUser, new Guid(StateHelper.Cookies.Preview.GetValue()), true); + if (_previewContent.ValidPreviewSet) + _previewContent.LoadPreviewset(); + } + if (_previewContent.ValidPreviewSet) + return _previewContent.XmlContent; + } + return content.Instance.XmlContent; + }); + } + set { _xmlDelegate = value; } + } + /// /// Returns the XML Cache document /// @@ -152,19 +186,7 @@ namespace Umbraco.Web /// internal XmlDocument GetXml() { - if (InPreviewMode) - { - if (_previewContent == null) - { - _previewContent = new PreviewContent(UmbracoUser, new Guid(StateHelper.Cookies.Preview.GetValue()), true); - if (_previewContent.ValidPreviewSet) - _previewContent.LoadPreviewset(); - } - if (_previewContent.ValidPreviewSet) - return _previewContent.XmlContent; - } - return content.Instance.XmlContent; - + return GetXmlDelegate(); } /// diff --git a/src/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg b/src/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..2d13fde968d805e1837af0aee7af4e113ea7ff6d GIT binary patch literal 193870 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�u+-`jfJFhsP(5ForswQ3K^ghg`KrE|BYQ*$CtZ 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⪚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 literal 0 HcmV?d00001 diff --git a/src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll b/src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll new file mode 100644 index 0000000000000000000000000000000000000000..c6f4f5388299037faf66075dec72f5e46f9a001a GIT binary patch literal 317952 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

FH#821o{s<`Oto0iZ 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 Z-2*2i+_lDClNbJXH}n6u?&&@7e*g%JNG$*W literal 0 HcmV?d00001 diff --git a/src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml b/src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml new file mode 100644 index 0000000000..d6ae366d25 --- /dev/null +++ b/src/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml @@ -0,0 +1,5624 @@ + + + + Rhino.Mocks + + + +

+ Defines constraints and return values for arguments of a mock. + Only use Arg inside a method call on a mock that is recording. + Example: + ExpectCall( + mock.foo( + Arg<int>.Is.GreaterThan(2), + Arg<string>.Is.Anything + )); + Use Arg.Text for string specific constraints + Use Arg<ListClass>.List for list specific constraints + + + + + + Register the predicate as a constraint for the current call. + + The predicate. + default(T) + + Allow you to use code to create constraints + + demo.AssertWasCalled(x => x.Bar(Arg{string}.Matches(a => a.StartsWith("b") && a.Contains("ba")))); + + + + + + Define a complex constraint for this argument by passing several constraints + combined with operators. (Use Is in simple cases.) + Example: Arg<string>.Matches(Is.Equal("Hello") || Text.EndsWith("u")); + + Constraints using Is, Text and List + Dummy to satisfy the compiler + + + + Define a Ref argument. + + Constraints for this argument + value returned by the mock + + + + + Define a out parameter. Use it together with the keyword out and use the + Dummy field available by the return value. + Example: mock.foo( out Arg<string>.Out("hello").Dummy ); + + + + + + + Define a simple constraint for this argument. (Use Matches in simple cases.) + Example: + Arg<int>.Is.Anthing + Arg<string>.Is.Equal("hello") + + + + + Define Constraints on list arguments. + + + + + Use the Arg class (without generic) to define Text constraints + + + + + Evaluate an equal constraint for . + + The object the parameter should equal to + + + + Define constraints on text arguments. + + + + + Used to manage the static state of the Arg<T> class"/> + + + + + Resets the static state + + + + + Returns return values for the out and ref parameters + Note: the array returned has the size of the number of out and ref + argument definitions + + + + + + Returns the constraints for all arguments. + Out arguments have an Is.Anything constraint and are also in the list. + + + + + + What should BackToRecord clear + + + + + Retain all expectations and behaviors and return to mock + + + + + All expectations + + + + + Event subscribers for this instance + + + + + Methods that should be forwarded to the base class implementation + + + + + Properties that should behave like properties + + + + + Remove all the behavior of the object + + + + + Interface for constraints + + + + + Determines if the object pass the constraints + + + + + And operator for constraints + + + + + Not operator for constraints + + + + + Or operator for constraints + + + + + Allow overriding of || or && + + + + + + + Allow overriding of || or && + + + + + + + Gets the message for this constraint + + + + + + Constrain that the public field has a specified value + + + + + Constrain that the public field matches another constraint. + + + + + Creates a new instance. + + Name of the public field. + Constraint to place on the public field value. + + + + Creates a new instance, specifying a disambiguating + for the public field. + + The type that declares the public field, used to disambiguate between public fields. + Name of the public field. + Constraint to place on the public field value. + + + + Determines if the object passes the constraint. + + + + + Gets the message for this constraint + + + + + + Creates a new instance. + + Name of the public field. + Expected value. + + + + Creates a new instance, specifying a disambiguating + for the public field. + + The type that declares the public field, used to disambiguate between public fields. + Name of the public field. + Expected value. + + + + Constrain that the property has a specified value + + + + + Constrain that the property matches another constraint. + + + + + Creates a new instance. + + Name of the property. + Constraint to place on the property value. + + + + Creates a new instance, specifying a disambiguating + for the property. + + The type that declares the property, used to disambiguate between properties. + Name of the property. + Constraint to place on the property value. + + + + Determines if the object passes the constraint. + + + + + Gets the message for this constraint + + + + + + Creates a new instance. + + Name of the property. + Expected value. + + + + Creates a new instance, specifying a disambiguating + for the property. + + The type that declares the property, used to disambiguate between properties. + Name of the property. + Expected value. + + + + Constrain that the parameter must be of the specified type + + + + + Creates a new instance. + + Type. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that determines whether an object is the same object as another. + + + + + Creates a new instance. + + Obj. + + + + Determines if the object passes the constraints. + + + + + Gets the message for this constraint. + + + + + Evaluate a parameter using constraints + + + + + Create new instance + + + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + A constraint based on lambda expression, we are using Expression{T} + because we want to be able to get good error reporting on that. + + + + + Initializes a new instance of the class. + + The expr. + + + + Determines if the object pass the constraints + + + + + + + Gets the message for this constraint + + + + + + Constrain that the list contains the same items as the parameter list + + + + + Creates a new instance. + + In list. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constrain that the parameter is one of the items in the list + + + + + Creates a new instance. + + In list. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constrain that the object is inside the parameter list + + + + + Creates a new instance. + + In list. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Applies another AbstractConstraint to the collection count. + + + + + Creates a new instance. + + The constraint that should be applied to the collection count. + + + + Determines if the parameter conforms to this constraint. + + + + + Gets the message for this constraint. + + + + + Applies another AbstractConstraint to a specific list element. + + + + + Creates a new instance. + + The zero-based index of the list element. + The constraint that should be applied to the list element. + + + + Determines if the parameter conforms to this constraint. + + + + + Gets the message for this constraint + + + + + + Applies another AbstractConstraint to a specific generic keyed list element. + + + + + Creates a new instance. + + The key of the list element. + The constraint that should be applied to the list element. + + + + Determines if the parameter conforms to this constraint. + + + + + Gets the message for this constraint + + + + + + Constrains that all elements are in the parameter list + + + + + Initializes a new instance of the class. + + The these. + + + + Determines if the object pass the constraints + + + + + + + Gets the message for this constraint + + + + + + Combines two constraints, constraint pass if either is fine. + + + + + Creates a new instance. + + C1. + C2. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Negate a constraint + + + + + Creates a new instance. + + C1. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Combines two constraints + + + + + + Creates a new instance. + + C1. + C2. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constrain the argument to validate according to regex pattern + + + + + Creates a new instance. + + Pattern. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that evaluate whatever an argument contains the specified string. + + + + + Creates a new instance. + + Inner string. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that evaluate whatever an argument ends with the specified string + + + + + Creates a new instance. + + End. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that evaluate whatever an argument start with the specified string + + + + + Creates a new instance. + + Start. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that evaluate whatever an object equals another + + + + + Creates a new instance. + + Obj. + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that always returns true + + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Constraint that evaluate whatever a comparable is greater than another + + + + + Creates a new instance. + + + + + Determines if the object pass the constraints + + + + + Gets the message for this constraint + + + + + + Initializes a new constraint object. + + The expected object, The actual object is passed in as a parameter to the method + + + + Evaluate this constraint. + + The actual object that was passed in the method call to the mock. + True when the constraint is met, else false. + + + + Checks if the properties of the object + are the same as the properies of the object. + + The expected object + The actual object + True when both objects have the same values, else False. + + + + + + + + + This is the real heart of the beast. + + + + Used by CheckReferenceType to check all properties of the reference type. + + The expected object + The actual object + True when both objects have the same values, else False. + + + + Used by CheckReferenceType to check all fields of the reference type. + + The expected object + The actual object + True when both objects have the same values, else False. + + + + Checks the items of both collections + + The expected collection + + True if both collections contain the same items in the same order. + + + + Builds a propertyname from the Stack _properties like 'Order.Product.Price' + to be used in the error message. + + A nested property name. + + + + Rhino.Mocks uses this property to generate an error message. + + + A message telling the tester why the constraint failed. + + + + + Provides access to the constraintes defined in the class to be used in context + with the syntax. + + The type of the argument + + + + Evaluate a greater than constraint for . + + The object the parameter should be greater than + + + + Evaluate a less than constraint for . + + The object the parameter should be less than + + + + Evaluate a less than or equal constraint for . + + The object the parameter should be less than or equal to + + + + Evaluate a greater than or equal constraint for . + + The object the parameter should be greater than or equal to + + + + Evaluate an equal constraint for . + + The object the parameter should equal to + + + + Converts the object type to a better match if this is a primitive type. + + The obj. + + + + + Converts the object type to match. + + + Because of implicit conversions and the way ArgConstraints this method is needed to check + object type and potentially change the object type for a better "match" so that obj1.Equals(obj2) + will return the proper "answer" + + The obj. + + + + + Evaluate a not equal constraint for . + + The object the parameter should not equal to + + + + Evaluate a same as constraint. + + The object the parameter should the same as. + + + + Evaluate a not same as constraint. + + The object the parameter should not be the same as. + + + + Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead. + + + + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + A constraints that accept anything + + + + + + A constraint that accept only nulls + + + + + + A constraint that accept only non null values + + + + + + A constraint that accept only value of the specified type. + The check is performed on the type that has been defined + as the argument type. + + + + + Provides access to the constraints defined in the class to be used in context + with the syntax. + + + + + Determines whether the specified object is in the parameter. + The parameter must be IEnumerable. + + Obj. + + + + + Determines whatever the parameter is in the collection. + + + + + Determines that the parameter collection is identical to the specified collection + + + + + Determines that the parameter collection has the specified number of elements. + + The constraint that should be applied to the collection count. + + + + Determines that an element of the parameter collections conforms to another AbstractConstraint. + + The zero-based index of the list element. + The constraint which should be applied to the list element. + + + + Determines that all elements of the specified collection are in the the parameter collection + + The collection to compare against + The constraint which should be applied to the list parameter. + + + + Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead. + + + + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + Provides a dummy field to pass as out or ref argument. + + + + + + Dummy field to satisfy the compiler. Used for out and ref arguments. + + + + + Central location for constraints for object's public fields + + + + + Constrains the parameter to have a public field with the specified value + + Name of the public field. + Expected value. + + + + + Constrains the parameter to have a public field with the specified value. + + The type that declares the public field, used to disambiguate between public fields. + Name of the public field. + Expected value. + + + + + Constrains the parameter to have a public field satisfying a specified constraint. + + Name of the public field. + Constraint for the public field. + + + + Constrains the parameter to have a public field satisfying a specified constraint. + + The type that declares the public field, used to disambiguate between public fields. + Name of the public field. + Constraint for the public field. + + + + Determines whether the parameter has the specified public field and that it is null. + + Name of the public field. + + + + + Determines whether the parameter has the specified public field and that it is null. + + The type that declares the public field, used to disambiguate between public fields. + Name of the public field. + + + + + Determines whether the parameter has the specified public field and that it is not null. + + Name of the public field. + + + + + Determines whether the parameter has the specified public field and that it is not null. + + The type that declares the public field, used to disambiguate between public fields. + Name of the public field. + + + + + Central location for constraints + + + + + Evaluate a greater than constraint for . + + The object the parameter should be greater than + + + + Evaluate a less than constraint for . + + The object the parameter should be less than + + + + Evaluate a less than or equal constraint for . + + The object the parameter should be less than or equal to + + + + Evaluate a greater than or equal constraint for . + + The object the parameter should be greater than or equal to + + + + Evaluate an equal constraint for . + + The object the parameter should equal to + + + + Evaluate a not equal constraint for . + + The object the parameter should not equal to + + + + Evaluate a same as constraint. + + The object the parameter should the same as. + + + + Evaluate a not same as constraint. + + The object the parameter should not be the same as. + + + + A constraints that accept anything + + + + + + A constraint that accept only nulls + + + + + + A constraint that accept only non null values + + + + + + A constraint that accept only value of the specified type + + + + + A constraint that accept only value of the specified type + + + + + Evaluate a parameter using a predicate + + The predicate to use + + + + Central location for constraints about lists and collections + + + + + Determines whether the specified obj is in the parameter. + The parameter must be IEnumerable. + + Obj. + + + + + Determines whatever the parameter is in the collection. + + + + + Determines that the parameter collection is identical to the specified collection + + + + + Determines that the parameter collection has the specified number of elements. + + The constraint that should be applied to the collection count. + + + + Determines that an element of the parameter collections conforms to another AbstractConstraint. + + The zero-based index of the list element. + The constraint which should be applied to the list element. + + + + Determines that an element of the parameter collections conforms to another AbstractConstraint. + + The key of the element. + The constraint which should be applied to the element. + + + + Determines that all elements of the specified collection are in the the parameter collection + + The collection to compare against + The constraint which should be applied to the list parameter. + + + + Central location for constraints for object's properties + + + + + Constrains the parameter to have property with the specified value + + Name of the property. + Expected value. + + + + + Constrains the parameter to have property with the specified value. + + The type that declares the property, used to disambiguate between properties. + Name of the property. + Expected value. + + + + + Constrains the parameter to have a property satisfying a specified constraint. + + Name of the property. + Constraint for the property. + + + + Constrains the parameter to have a property satisfying a specified constraint. + + The type that declares the property, used to disambiguate between properties. + Name of the property. + Constraint for the property. + + + + Determines whether the parameter has the specified property and that it is null. + + Name of the property. + + + + + Determines whether the parameter has the specified property and that it is null. + + The type that declares the property, used to disambiguate between properties. + Name of the property. + + + + + Determines whether the parameter has the specified property and that it is not null. + + Name of the property. + + + + + Determines whether the parameter has the specified property and that it is not null. + + The type that declares the property, used to disambiguate between properties. + Name of the property. + + + + + constraints the parameter to have the exact same property values as the expected object. + + An object, of the same type as the parameter, whose properties are set with the expected values. + An instance of the constraint that will do the actual check. + + The parameter's public property values and public field values will be matched against the expected object's + public property values and public field values. The first mismatch will be reported and no further matching is done. + The matching is recursive for any property or field that has properties or fields of it's own. + Collections are supported through IEnumerable, which means the constraint will check if the actual and expected + collection contain the same values in the same order, where the values contained by the collection can have properties + and fields of their own that will be checked as well because of the recursive nature of this constraint. + + + + + Central location for all text related constraints + + + + + Constrain the argument to starts with the specified string + + + + + Constrain the argument to end with the specified string + + + + + Constrain the argument to contain the specified string + + + + + Constrain the argument to validate according to regex pattern + + + + + Provides access to the constraintes defined in the class to be used in context + with the syntax. + + + + + Constrain the argument to starts with the specified string + + + + + + Constrain the argument to end with the specified string + + + + + Constrain the argument to contain the specified string + + + + + Constrain the argument to validate according to regex pattern + + + + + Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead. + + + + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + This class defines a lot of method signatures, which we will use + to allow compatability on net-2.0 + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + dummy + + + + + Allows expectations to be set on methods that should never be called. + For methods with void return value, you need to use LastCall or + DoNotExpect.Call() with a delegate. + + + + + Sets LastCall.Repeat.Never() on /any/ proxy on /any/ repository on the current thread. + This method if not safe for multi threading scenarios. + + + + + Accepts a delegate that will execute inside the method which + LastCall.Repeat.Never() will be applied to. + It is expected to be used with anonymous delegates / lambda expressions and only one + method should be called. + + + IService mockSrv = mocks.CreateMock(typeof(IService)) as IService; + DoNotExpect.Call(delegate{ mockSrv.Stop(); }); + ... + + + + + An expectaton violation was detected. + + + + + Creates a new instance. + + Message. + + + + Serialization constructor + + + + + Signals that an object was call on a mock repository which doesn't + belong to this mock repository or not a mock + + + + + Creates a new instance. + + Message. + + + + Serialization constructor + + + + + Allows to set expectation on methods that has return values. + For methods with void return value, you need to use LastCall + + + + + The method options for the last call on /any/ proxy on /any/ repository on the current thread. + This method if not safe for multi threading scenarios, use . + + + + + Accepts a delegate that will execute inside the method, and then return the resulting + instance. + It is expected to be used with anonymous delegates / lambda expressions and only one + method should be called. + + + IService mockSrv = mocks.CreateMock(typeof(IService)) as IService; + Expect.Call(delegate{ mockSrv.Start(); }).Throw(new NetworkException()); + ... + + + + + Get the method options for the last method call on the mockInstance. + + + + + A delegate that can be used to get better syntax on Expect.Call(delegate { foo.DoSomething(); }); + + + + + Abstract class that holds common information for + expectations. + + + + + Interface to validate that a method call is correct. + + + + + Validate the arguments for the method. + This method can be called numerous times, so be careful about side effects + + The arguments with which the method was called + + + + Add an actual method call to this expectation + + + + + Returns the return value or throw the exception and setup any output / ref parameters + that has been set. + + + + + Builds the verification failure message. + + + + + + Gets the error message. + + + + + + Range of expected calls + + + + + Number of call actually made for this method + + + + + If this expectation is still waiting for calls. + + + + + The return value for a method matching this expectation + + + + + Gets or sets the exception to throw on a method matching this expectation. + + + + + Gets a value indicating whether this instance's action is staisfied. + A staisfied instance means that there are no more requirements from + this method. A method with non void return value must register either + a return value or an exception to throw. + + + + + Gets the method this expectation is for. + + + + + Gets or sets what special condtions there are for this method + repeating. + + + + + Gets a value indicating whether this expectation was satisfied + + + + + Specify whatever this expectation has a return value set + You can't check ReturnValue for this because a valid return value include null. + + + + + An action to execute when the method is matched. + + + + + Set the out / ref parameters for the method call. + The indexing is zero based and ignores any non out/ref parameter. + It is possible not to pass all the parameters. This method can be called only once. + + + + + Documentation Message + + + + + Gets the invocation for this expectation + + The invocation. + + + + Occurs when the exceptation is match on a method call + + + + + Allow to set the return value in the future, if it was already set. + + + + + Number of actuall calls made that passed this expectation + + + + + Range of expected calls that should pass this expectation. + + + + + The return value for a method matching this expectation + + + + + The exception to throw on a method matching this expectation. + + + + + The method this expectation is for. + + + + + The return value for this method was set + + + + + Whether this method will repeat + unlimited number of times. + + + + + A delegate that will be run when the + expectation is matched. + + + + + The arguments that matched this expectation. + + + + + Documentation message + + + + + The method originalInvocation + + + + + Get the hash code + + + + + Add an actual actualMethodCall call to this expectation + + + + + Builds the verification failure message. + + + + + + Returns the return value or throw the exception and setup output / ref parameters + + + + + Validate the arguments for the method on the child methods + + The arguments with which the method was called + + + + Creates a new instance. + + The originalInvocation for this method, required because it contains the generic type infromation + Number of method calls for this expectations + + + + Creates a new instance. + + Expectation. + + + + Validate the arguments for the method on the child methods + + The arguments with which the method was called + + + + Determines if this object equal to obj + + + + + The error message for these arguments + + + + + Asserts that the delegate has the same parameters as the expectation's method call + + + + + Setter for the outpur / ref parameters for this expecataion. + Can only be set once. + + + + + Specify whether this expectation has a return value set + You can't check ReturnValue for this because a valid return value include null. + + + + + Gets the method this expectation is for. + + + + + Gets the originalInvocation for this expectation + + The originalInvocation. + + + + Gets or sets what special condtions there are for this method + + + + + Range of expected calls + + + + + Number of call actually made for this method + + + + + If this expectation is still waiting for calls. + + + + + Gets a value indicating whether this expectation was satisfied + + + + + The return value for a method matching this expectation + + + + + An action to execute when the method is matched. + + + + + Gets or sets the exception to throw on a method matching this expectation. + + + + + Gets a value indicating whether this instance's action is staisfied. + A staisfied instance means that there are no more requirements from + this method. A method with non void return value must register either + a return value or an exception to throw or an action to execute. + + + + + Documentation message + + + + + Occurs when the exceptation is match on a method call + + + + + Allow to set the return value in the future, if it was already set. + + + + + Gets the error message. + + + + + + Expectation that matches any arguments for the method. + + + + + Creates a new instance. + + Invocation for this expectation + Number of method calls for this expectations + + + + Creates a new instance. + + Expectation. + + + + Validate the arguments for the method. + + The arguments with which the method was called + + + + Determines if the object equal to expectation + + + + + Get the hash code + + + + + Gets the error message. + + + + + + Summary description for ArgsEqualExpectation. + + + + + Creates a new instance. + + Expected args. + The invocation for this expectation + Number of method calls for this expectations + + + + Validate the arguments for the method. + + The arguments with which the method was called + + + + Determines if the object equal to expectation + + + + + Get the hash code + + + + + Gets the error message. + + + + + + Get the expected args. + + + + + Call a specified callback to verify the expectation + + + + + Creates a new instance. + + Expectation. + Callback. + + + + Creates a new instance. + + Invocation for this expectation + Callback. + Number of method calls for this expectations + + + + Validate the arguments for the method on the child methods + + The arguments with which the method was called + + + + Determines if the object equal to expectation + + + + + Get the hash code + + + + + Gets the error message. + + + + + + Expect the method's arguments to match the contraints + + + + + Creates a new instance. + + Invocation for this expectation + Constraints. + Number of method calls for this expectations + + + + Creates a new instance. + + Expectation. + Constraints. + + + + Validate the arguments for the method. + + The arguments with which the method was called + + + + Determines if the object equal to expectation + + + + + Get the hash code + + + + + Gets the error message. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Summary for AndSpecification + + + + + + + + + + + + + + + + + + + + + + Summary description for FollowsEventNamingStandard + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Summary descritpion for NamedEventExistsOnDeclaringType + + + + + + + + + Doesn't log anything, just makes happy noises + + + + + Log expectations - allows to see what is going on inside Rhino Mocks + + + + + Logs the expectation as is was recorded + + The invocation. + The expectation. + + + + Logs the expectation as it was recorded + + The invocation. + The expectation. + + + + Logs the unexpected method call. + + The invocation. + The message. + + + + Logs the expectation as is was recorded + + The invocation. + The expectation. + + + + Logs the expectation as it was recorded + + The invocation. + The expectation. + + + + Logs the unexpected method call. + + The invocation. + The message. + + + + Operation on a remoting proxy + + + It is not possible to directly communicate to a real proxy via transparent proxy. + Transparent proxy impersonates a user type and only methods of that user type are callable. + The only methods that are guaranteed to exist on any transparent proxy are methods defined + in Object: namely ToString(), GetHashCode(), and Equals()). + + These three methods are the only way to tell the real proxy to do something. + Equals() is the most suitable of all, since it accepts an arbitrary object parameter. + The RemotingProxy code is built so that if it is compared to an IRemotingProxyOperation, + transparentProxy.Equals(operation) will call operation.Process(realProxy). + This way we can retrieve a real proxy from transparent proxy and perform + arbitrary operation on it. + + + + + Generates remoting proxies and provides utility functions + + + + + Create the proxy using remoting + + + + + Check whether an object is a transparent proxy with a RemotingProxy behind it + + Object to check + true if the object is a transparent proxy with a RemotingProxy instance behind it, false otherwise + We use Equals() method to communicate with the real proxy behind the object. + See IRemotingProxyOperation for more details + + + + Retrieve a mocked object from a transparent proxy + + Transparent proxy with a RemotingProxy instance behind it + Mocked object associated with the proxy + We use Equals() method to communicate with the real proxy behind the object. + See IRemotingProxyOperation for more details + + + + Implementation of IInvocation based on remoting proxy + + Some methods are marked NotSupported since they either don't make sense + for remoting proxies, or they are never called by Rhino Mocks + + + + Rudimetry implementation that simply logs methods calls as text. + + + + + Initializes a new instance of the class. + + The writer. + + + + Logs the expectation as it was recorded + + The invocation. + The expectation. + + + + Logs the expectation as it was recorded + + The invocation. + The expectation. + + + + Logs the unexpected method call. + + The invocation. + The message. + + + + Behave like a stub, all properties and events acts normally, methods calls + return default values by default (but can use expectations to set them up), etc. + + + + + Records all the expectations for a mock + + + + + Different actions on this mock + + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Verify that this mock expectations have passed. + + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Gets a mock state that match the original mock state of the object. + + + + + Get the options for the last method call + + + + + Set the exception to throw when Verify is called. + This is used to report exception that may have happened but where caught in the code. + This way, they are reported anyway when Verify() is called. + + + + + This method is called to indicate that a property behavior call. + This is done so we generate good error message in the common case of people using + Stubbed properties with Return(). + + + + + Gets the matching verify state for this state + + + + + Get the options for the last method call + + + + + Get the options for the last method call + + + + + Set the exception to throw when Verify is called. + This is used to report exception that may have happened but where caught in the code. + This way, they are reported anyway when Verify() is called. + + + + + This method is called to indicate that a property behavior call. + This is done so we generate good error message in the common case of people using + Stubbed properties with Return(). + + + + + Creates a new instance. + + Repository. + The proxy that generates the method calls + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Verify that this mock expectations have passed. + + + + + Gets a mock state that match the original mock state of the object. + + + + + Asserts the previous method is closed (had an expectation set on it so we can replay it correctly) + + + + + Get the default call count range expectation + + + + + + Gets the last expectation. + + + + + Gets the total method calls count. + + + + + Get the options for the last method call + + + + + Gets the matching verify state for this state + + + + + Initializes a new instance of the class. + + The proxy that generates the method calls + Repository. + + + + We don't care much about expectations here, so we will remove the expectation if + it is not closed. + + + + + Verify that we can move to replay state and move + to the reply state. + + + + + + Get the default call count range expectation + + + + + + Validate expectations on recorded methods, but in general completely ignoring them. + Similar to except that it would return a + when BackToRecord is called. + + + + + Validate all expectations on a mock + + + + + The repository for this state + + + + + The proxy object for this state + + + + + Get the options for the last method call + + + + + Creates a new instance. + + The previous state for this method + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Add a method call for this state' mock. + This allows derived method to cleanly get a the setupresult behavior while adding + their own. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Set the exception to throw when Verify is called. + This is used to report exception that may have happened but where caught in the code. + This way, they are reported anyway when Verify() is called. + + + + + not relevant + + + + + Verify that this mock expectations have passed. + + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Gets a mock state that match the original mock state of the object. + + + + + Get the options for the last method call + + + + + Gets the matching verify state for this state + + + + + Initializes a new instance of the class. + + The previous state for this method + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Gets a mock state that matches the original mock state of the object. + + + + + Write rhino mocks log info to the trace + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + if set to true [log recorded]. + if set to true [log replayed]. + if set to true [log unexpected]. + + + + Logs the expectation as is was recorded + + The invocation. + The expectation. + + + + Logs the expectation as it was recorded + + The invocation. + The expectation. + + + + Logs the unexpected method call. + + The invocation. + The message. + + + + Writes log information as stack traces about rhino mocks activity + + + + + Allows to redirect output to a different location. + + + + + Logs the expectation as is was recorded + + The invocation. + The expectation. + + + + Logs the expectation as it was recorded + + The invocation. + The expectation. + + + + Logs the unexpected method call. + + The invocation. + The message. + + + + Marker interface used to indicate that this is a partial mock. + + + + + Options for CallOriginalMethod + + + + + No expectation is created, the method will be called directly + + + + + Normal expectation is created, but when the method is later called, it will also call the original method + + + + + This is a data structure that is used by + to pass + the current method to the relevant delegate + + + + + Initializes a new instance of the class. + + The invocation. + + + + Gets the args for this method invocation + + + + + Get the method that was caused this invocation + + + + + Gets or sets the return value for this method invocation + + The return value. + + + + Adds optional new usage: + using(mockRepository.Record()) { + Expect.Call(mock.Method()).Return(retVal); + } + using(mockRepository.Playback()) { + // Execute code + } + N.B. mockRepository.ReplayAll() and mockRepository.VerifyAll() + calls are taken care of by Record/Playback + + + Creates proxied instances of types. + + + + Generates a stub without needing a + Arguments for 's constructor + The of stub to create. + The stub + + + + Generates a stub without needing a + The of stub. + Arguments for the 's constructor. + The stub + + + + Generate a mock object without needing a + type of mock object to create. + Arguments for 's constructor + the mock object + + + + Generate a multi-mock object without needing a + The typeof object to generate a mock for. + A second interface to generate a multi-mock for. + Arguments for 's constructor + the multi-mock object + + + + Generate a multi-mock object without without needing a + The typeof object to generate a mock for. + An interface to generate a multi-mock for. + A second interface to generate a multi-mock for. + Arguments for 's constructor + the multi-mock object + + + + Creates a multi-mock without without needing a + The type of mock to create, this can be a class + Any extra interfaces to add to the multi-mock, these can only be interfaces. + Arguments for 's constructor + the multi-mock object + + + + Creates a strict mock without without needing a + Any arguments required for the 's constructor + The type of mock object to create. + The mock object with strict replay semantics + + + + Creates a strict multi-mock without needing a + Any arguments required for the 's constructor + The type of mock object to create, this can be a class. + An interface to generate a multi-mock for, this must be an interface! + The multi-mock object with strict replay semantics + + + + Creates a strict multi-mock without needing a + Any arguments required for the 's constructor + The type of mock object to create, this can be a class. + An interface to generate a multi-mock for, this must be an interface! + A second interface to generate a multi-mock for, this must be an interface! + The multi-mock object with strict replay semantics + + + + Creates a strict multi-mock without needing a + The type of mock object to create, this can be a class + Any extra interfaces to generate a multi-mock for, these must be interaces! + Any arguments for the 's constructor + The strict multi-mock object + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Generate a mock object with dynamic replay semantics and remoting without needing the mock repository + + + + + Generate a mock object with strict replay semantics and remoting without needing the mock repository + + + + Helper method to create a mock object without a repository instance and put the object back into replay mode. + The type of mock object to create + A delegate that uses a mock repository instance to create the underlying mock + The mock object in the replay mode. + + + + + + + + + + + + + + This is a map of types to ProxyGenerators. + + + + + This is used to record the last repository that has a method called on it. + + + + + this is used to get to the last proxy on this repository. + + + + + For mock delegates, maps the proxy instance from intercepted invocations + back to the delegate that was originally returned to client code, if any. + + + + + All the proxies in the mock repositories + + + + + This is here because we can't put it in any of the recorders, since repeatable methods + have no orderring, and if we try to handle them using the usual manner, we would get into + wierd situations where repeatable method that was defined in an orderring block doesn't + exists until we enter this block. + + + + + Creates a new instance. + + + + + Move the repository to ordered mode + + + + + Move the repository to un-ordered mode + + + + + Creates a mock for the specified type. + + Type. + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a strict mock for the specified type. + + Type. + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a remoting mock for the specified type. + + Type. + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a strict remoting mock for the specified type. + + Type. + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a remoting mock for the specified type. + + + Arguments for the class' constructor, if mocking a concrete class + + + + + Creates a strict remoting mock for the specified type. + + + Arguments for the class' constructor, if mocking a concrete class + + + + + Creates a mock from several types, with strict semantics. + Only may be a class. + + + + + Creates a strict mock from several types, with strict semantics. + Only may be a class. + + + + + Creates a mock from several types, with strict semantics. + Only may be a class. + + The main type to mock. + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class. + + + + Creates a strict mock from several types, with strict semantics. + Only may be a class. + + The main type to mock. + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class. + + + + Creates a mock from several types, with dynamic semantics. + Only may be a class. + + The main type to mock. + Extra interface types to mock. + + + + Creates a mock from several types, with dynamic semantics. + Only may be a class. + + The main type to mock. + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class. + + + Creates a dynamic mock for the specified type. + Type. + Arguments for the class' constructor, if mocking a concrete class + + + Creates a dynamic mock for the specified type. + Type. + Arguments for the class' constructor, if mocking a concrete class + + + Creates a dynamic mock for the specified type. + + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a mock object that defaults to calling the class methods if no expectation is set on the method. + Type. + Arguments for the class' constructor. + + + Creates a mock object that defaults to calling the class methods. + Type. + Extra interface types to mock. + + + Creates a mock object that defaults to calling the class methods. + Type. + Extra interface types to mock. + Arguments for the class' constructor. + + + Creates a mock object using remoting proxies + Type to mock - must be MarshalByRefObject + Mock object + Proxy mock can mock non-virtual methods, but not static methods + Creates the mock state for this proxy + + + + Cause the mock state to change to replay, any further call is compared to the + ones that were called in the record state. + + This method *cannot* be called from inside an ordering. + the object to move to replay state + + + + Cause the mock state to change to replay, any further call is compared to the + ones that were called in the record state. + + the object to move to replay state + + + + Move the mocked object back to record state.You can (and it's recommended) to run {Verify()} before you use this method. + Will delete all current expectations! + + + + Move the mocked object back to record state. + Optionally, can delete all current expectations, but allows more granularity about how + it would behave with regard to the object state. + + + + + Verify that all the expectations for this object were fulfilled. + + the object to verify the expectations for + + + + Get the method options for the last call on + mockedInstance. + + The mock object + Method options for the last call + + + + Maps an invocation proxy back to the mock object instance that was originally + returned to client code which might have been a delegate to this proxy. + + The mock object proxy from the intercepted invocation + The mock object + + + This is provided to allow advance extention functionality, where Rhino Mocks standard functionality is not enough. + The type to mock + Delegate that create the first state of the mocked object (usualy the record state). + Additional types to be implemented, this can be only interfaces + optional arguments for the constructor + + + + + Method: GetMockedObject + Get an IProxy from a mocked object instance, or throws if the + object is not a mock object. + + + + + Method: GetMockedObjectOrNull + Get an IProxy from a mocked object instance, or null if the + object is not a mock object. + + + + Pops the recorder. + + + Pushes the recorder. + New recorder. + + + + All the mock objects in this repository will be moved + to record state. + + + + + All the mock objects in this repository will be moved + to record state. + + + + + Replay all the mocks from this repository + + + + + Verify all the mocks from this repository + + + + + Gets the proxy generator for a specific type. Having a single ProxyGenerator + with multiple types linearly degrades the performance so this implementation + keeps one ProxyGenerator per type. + + + + Set the exception to be thrown when verified is called. + + + + Creates a mock for the spesified type with strict mocking semantics. + Strict semantics means that any call that wasn't explicitly recorded is considered an error and would cause an exception to be thrown. + + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a mock for the spesified type with strict mocking semantics. + Strict semantics means that any call that wasn't explicitly recorded is considered an error and would cause an exception to be thrown. + + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a dynamic mock for the specified type. + + Arguments for the class' constructor, if mocking a concrete class + + + + Creates a mock object from several types. + + + + + Creates a strict mock object from several types. + + + + + Create a mock object from several types with dynamic semantics. + + + + + Create a mock object from several types with partial semantics. + + + + + Create a mock object from several types with strict semantics. + + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class + + + + Create a strict mock object from several types with strict semantics. + + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class + + + + Create a mock object from several types with dynamic semantics. + + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class + + + + Create a mock object from several types with partial semantics. + + Extra interface types to mock. + Arguments for the class' constructor, if mocking a concrete class + + + + Create a mock object with from a class that defaults to calling the class methods + + Arguments for the class' constructor, if mocking a concrete class + + + + Create a stub object, one that has properties and events ready for use, and + can have methods called on it. It requires an explicit step in order to create + an expectation for a stub. + + The arguments for constructor. + + + + Create a stub object, one that has properties and events ready for use, and + can have methods called on it. It requires an explicit step in order to create + an expectation for a stub. + + The type. + The arguments for constructor. + The stub + + + + Returns true if the passed mock is currently in replay mode. + + The mock to test. + True if the mock is in replay mode, false otherwise. + + + + Determines whether the specified proxy is a stub. + + The proxy. + + + + Register a call on a prperty behavior + + + + + + Gets the recorder. + + + + + + Gets the replayer for this repository. + + + + + + Gets the last proxy which had a method call. + + + + + Delegate: CreateMockState + This is used internally to cleanly handle the creation of different + RecordMockStates. + + + + + A set of extension methods that adds Arrange Act Assert mode to Rhino Mocks + + + + + Create an expectation on this mock for this action to occur + + + The mock. + The action. + + + + + Reset all expectations on this mock object + + + The mock. + + + + Reset the selected expectation on this mock object + + + The mock. + The options to reset the expectations on this mock. + + + + Cause the mock state to change to replay, any further call is compared to the + ones that were called in the record state. + + the mocked object to move to replay state + + + + Gets the mock repository for this specificied mock object + + + The mock. + + + + + Create an expectation on this mock for this action to occur + + + + The mock. + The action. + + + + + Tell the mock object to perform a certain action when a matching + method is called. + Does not create an expectation for this method. + + + The mock. + The action. + + + + + Tell the mock object to perform a certain action when a matching + method is called. + Does not create an expectation for this method. + + + + The mock. + The action. + + + + + Gets the arguments for calls made on this mock object and the method that was called + in the action. + + + The mock. + The action. + + + Here we will get all the arguments for all the calls made to DoSomething(int) + + var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0)) + + + + + + Gets the arguments for calls made on this mock object and the method that was called + in the action and matches the given constraints + + + The mock. + The action. + The setup constraints. + + + Here we will get all the arguments for all the calls made to DoSomething(int) + + var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0)) + + + + + + Asserts that a particular method was called on this mock object + + + The mock. + The action. + + + + Asserts that a particular method was called on this mock object that match + a particular constraint set. + + + The mock. + The action. + The setup constraints. + + + + Asserts that a particular method was called on this mock object that match + a particular constraint set. + + + The mock. + The action. + + + + Asserts that a particular method was called on this mock object that match + a particular constraint set. + + + The mock. + The action. + The setup constraints. + + + + Asserts that a particular method was NOT called on this mock object + + + The mock. + The action. + + + + Asserts that a particular method was NOT called on this mock object that match + a particular constraint set. + + + The mock. + The action. + The setup constraints. + + + + Asserts that a particular method was NOT called on this mock object + + + The mock. + The action. + + + + Asserts that a particular method was NOT called on this mock object + + + The mock. + The action. + The setup constraints. + + + + Finds the approprite implementation type of this item. + This is the class or an interface outside of the rhino mocks. + + The mocked obj. + + + + + Verifies all expectations on this mock object + + The mock object. + + + + Gets the event raiser for the event that was called in the action passed + + The type of the event source. + The mock object. + The event subscription. + + + + + Raise the specified event using the passed arguments. + The even is extracted from the passed labmda + + The type of the event source. + The mock object. + The event subscription. + The sender. + The instance containing the event data. + + + + Raise the specified event using the passed arguments. + The even is extracted from the passed labmda + + The type of the event source. + The mock object. + The event subscription. + The args. + + + TODO: Make this better! It currently breaks down when mocking classes or + ABC's that call other virtual methods which are getting intercepted too. I wish + we could just walk Expression{Action{Action{T}} to assert only a single + method is being made. + + The workaround is to not call foo.AssertWasCalled .. rather foo.VerifyAllExpectations() + The type of mock object + The mock repository + The actual mock object to assert expectations on. + + + + Fake type that disallow creating it. + Should have been System.Type, but we can't use it. + + + + + Utility class for dealing with messing generics scenarios. + + + + + There are issues with trying to get this to work correctly with open generic types, since this is an edge case, + I am letting the runtime handle it. + + + + + Gets the real type, including de-constructing and constructing the type of generic + methods parameters. + + The type. + The invocation. + + + + + Because we need to support complex types here (simple generics were handled above) we + need to be aware of the following scenarios: + List[T] and List[Foo[T]] + + + + + ExpectationsList + + + + + Dictionary + + + + + Dictionary class + + + + + Create a new instance of ProxyStateDictionary + + + + + Allows to call a method and immediately get it's options. + + + + + Interface to allow calling a method and immediately get it's options. + + + + + Get the method options for the call + + The method call should go here, the return value is ignored + + + + Creates a new instance. + + + + + Get the method options for the call + + The method call should go here, the return value is ignored + + + + Allows to call a method and immediately get it's options. + Set the expected number for the call to Any() + + + + + Creates a new instance. + + Proxy. + Mocked instance. + + + + Get the method options for the call + + The method call should go here, the return value is ignored + + + + This class is reponsible for taking a delegate and creating a wrapper + interface around it, so it can be mocked. + + + + + The scope for all the delegate interfaces create by this mock repository. + + + + + Gets a type with an "Invoke" method suitable for use as a target of the + specified delegate type. + + + + + + + Raise events for all subscribers for an event + + + + + Raise events for all subscribers for an event + + + + + Raise the event + + + + + The most common form for the event handler signature + + + + + Create an event raiser for the specified event on this instance. + + + + + Creates a new instance of EventRaiser + + + + + Raise the event + + + + + The most common signature for events + Here to allow intellisense to make better guesses about how + it should suggest parameters. + + + + + Allows to define what would happen when a method + is called. + + + + + Allows to define what would happen when a method + is called. + + + + + Set the return value for the method. + + The object the method will return + IRepeat that defines how many times the method will return this value + + + + Allow to override this return value in the future + + IRepeat that defines how many times the method will return this value + + + + Throws the specified exception when the method is called. + + Exception to throw + + + + Ignores the arguments for this method. Any argument will be matched + againt this method. + + + + + Add constraints for the method's arguments. + + + + + Set a callback method for the last call + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched + and allow to optionally modify the invocation as needed + + + + + Call the original method on the class, bypassing the mocking layers. + + + + + + Call the original method on the class, optionally bypassing the mocking layers. + + + + + + Use the property as a simple property, getting/setting the values without + causing mock expectations. + + + + + Expect last (property) call as property setting, ignore the argument given + + + + + + Expect last (property) call as property setting with a given argument. + + + + + + + Get an event raiser for the last subscribed event. + + + + + Set the parameter values for out and ref parameters. + This is done using zero based indexing, and _ignoring_ any non out/ref parameter. + + + + + Documentation message for the expectation + + Message + + + + Better syntax to define repeats. + + + + + Allows to specify the number of time for method calls + + + + + Repeat the method twice. + + + + + Repeat the method once. + + + + + Repeat the method at least once, then repeat as many time as it would like. + + + + + Repeat the method any number of times. + This has special affects in that this method would now ignore orderring. + + + + + Set the range to repeat an action. + + Min. + Max. + + + + Set the amount of times to repeat an action. + + + + + This method must not appear in the replay state. + This has special affects in that this method would now ignore orderring. + + + + + Creates a new instance. + + the repository for this expectation + the recorder for this proxy + the proxy for this expectation + Expectation. + + + + Add constraints for the method's arguments. + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Set the return value for the method. + + The object the method will return + IRepeat that defines how many times the method will return this value + + + + Set the return value for the method, but allow to override this return value in the future + + IRepeat that defines how many times the method will return this value + + + + Throws the specified exception when the method is called. + + Exception to throw + + + + Ignores the arguments for this method. Any argument will be matched + againt this method. + + + + + Call the original method on the class, bypassing the mocking layers. + + + + + + Call the original method on the class, optionally bypassing the mocking layers + + + + + + Use the property as a simple property, getting/setting the values without + causing mock expectations. + + + + + Expect last (property) call as property setting, ignore the argument given + + + + + + Expect last (property) call as property setting with a given argument. + + + + + + + Gets the event raiser for the last event + + + + + Set the parameter values for out and ref parameters. + This is done using zero based indexing, and _ignoring_ any non out/ref parameter. + + + + + Repeat the method twice. + + + + + Repeat the method once. + + + + + Repeat the method at least once, then repeat as many time as it would like. + + + + + This method must not appear in the replay state. + + + + + Documentation message for the expectation + + Message + + + + Repeat the method any number of times. + + + + + Set the range to repeat an action. + + Min. + Max. + + + + Set the amount of times to repeat an action. + + + + + Better syntax to define repeats. + + + + + This class will provide hash code for hashtables without needing + to call the GetHashCode() on the object, which may very well be mocked. + This class has no state so it is a singelton to avoid creating a lot of objects + that does the exact same thing. See flyweight patterns. + + + + + Get the hash code for a proxy object without calling GetHashCode() + on the object. + + + + + Compares two instances of mocked objects + + + + + Compare two mocked objects + + + + + The next hash code value for a mock object. + This is safe for multi threading. + + + + + The sole instance of + + + + + This is a dummy type that is used merely to give DynamicProxy the proxy instance that + it needs to create IProxy's types. + + + + + Interface to find the repository of a mocked object + + + + + Return true if it should call the original method on the object + instead of pass it to the message chain. + + The method to call + + + + Register a method to be called on the object directly + + + + + Register a property on the object that will behave as a simple property + + + + + Check if the method was registered as a property method. + + + + + Do get/set on the property, according to need. + + + + + Do add/remove on the event + + + + + Get the subscribers of a spesific event + + + + + Gets the declaring type of the method, taking into acccount the possible generic + parameters that it was created with. + + + + + Clears the state of the object, remove original calls, property behavior, subscribed events, etc. + + + + + Get all the method calls arguments that were made against this object with the specificed + method. + + + Only method calls in replay mode are counted + + + + + Records the method call + + + + + Mocks that are tied to this mock lifestyle + + + + + The unique hash code of this mock, which is not related + to the value of the GetHashCode() call on the object. + + + + + Gets the repository. + + + + + Gets the implemented types by this mocked object + + The implemented. + + + + Gets or sets the constructor arguments. + + The constructor arguments. + + + + The mocked instance that this is representing + + + + + Create a new instance of + + + + + Return true if it should call the original method on the object + instead of pass it to the message chain. + + The method to call + + + + Register a method to be called on the object directly + + + + + Register a property on the object that will behave as a simple property + Return true if there is already a value for the property + + + + + Check if the method was registered as a property method. + + + + + Do get/set on the property, according to need. + + + + + Do add/remove on the event + + + + + Get the subscribers of a spesific event + + + + + Gets the declaring type of the method, taking into acccount the possible generic + parameters that it was created with. + + + + + Get all the method calls arguments that were made against this object with the specificed + method. + + + + + Only method calls in replay mode are counted + + + + + Records the method call + + + + + + + Clears the state of the object, remove original calls, property behavior, subscribed events, etc. + + + + + Mocks that are tied to this mock lifestyle + + + + + The unique hash code of this proxy, which is not related + to the value of the GetHashCode() call on the object. + + + + + Gets the repository. + + + + + Gets or sets the constructor arguments. + + The constructor arguments. + + + + The mocked instance that this is representing + + + + + Gets the implemented types by this mocked object + + The implemented. + + + + Range for expected method calls + + + + + Creates a new instance. + + Min. + Max. + + + + Return the string representation of this range. + + + + + Gets or sets the min. + + + + + + Gets or sets the max. + + + + + + Records all the expectations for a mock and + return a ReplayDynamicMockState when Replay() + is called. + + + + + Creates a new instance. + + Repository. + The proxy that generates the method calls + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Get the default call count range expectation + + + + + + Gets a mock state that match the original mock state of the object. + + + + + Records all the expectations for a mock and + return a ReplayPartialMockState when Replay() + is called. + + + + + Creates a new instance. + + Repository. + The proxy that generates the method calls + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Gets a mock state that matches the original mock state of the object. + + + + + Options for special repeat option + + + + + This method can be called only as many times as the IMethodOptions.Expect allows. + + + + + This method should never be called + + + + + This method can be call any number of times + + + + + This method will call the original method + + + + + This method will call the original method, bypassing the mocking layer + + + + + This method will simulate simple property behavior + + + + + Validate all expectations on a mock and ignores calls to + any method that was not setup properly. + + + + + Creates a new instance. + + The previous state for this method + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Gets a mock state that match the original mock state of the object. + + + + + Validate all expectations on a mock and ignores calls to + any method that was not setup properly. + + + + + Creates a new instance. + + The previous state for this method + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Gets a mock state that match the original mock state of the object. + + + + + Summary description for RhinoInterceptor. + + + + + Creates a new instance. + + + + + Intercept a method call and direct it to the repository. + + + + + Validate arguments for methods + + + + + Validate that the passed argument is not null. + + The object to validate + The name of the argument + + If the obj is null, an ArgumentNullException with the passed name + is thrown. + + + + + Validate that the arguments are equal. + + Expected args. + Actual Args. + + + + Validate that the two arguments are equals, including validation for + when the arguments are collections, in which case it will validate their values. + + + + + This method is safe for use even if any of the objects is a mocked object + that override equals. + + + + + Throw an object already verified when accessed + + + + + Create a new instance of VerifiedMockState + + The previous mock state, used to get the initial record state + + + + Add a method call for this state' mock. + + The invocation for this method + The method that was called + The arguments this method was called with + + + + Verify that this mock expectations have passed. + + + + + Verify that we can move to replay state and move + to the reply state. + + + + + Gets a mock state that match the original mock state of the object. + + + + + Get the options for the last method call + + + + + Set the exception to throw when Verify is called. + This is used to report exception that may have happened but where caught in the code. + This way, they are reported anyway when Verify() is called. + + + + + not relevant + + + + + Gets the matching verify state for this state + + + + + Get the options for the last method call + + + + + Records the actions on all the mocks created by a repository. + + + + + Records the specified call with the specified args on the mocked object. + + + + + Get the expectation for this method on this object with this arguments + + + + + This check the methods that were setup using the SetupResult.For() + or LastCall.Repeat.Any() and that bypass the whole expectation model. + + + + + Gets the all expectations for a mocked object and method combination, + regardless of the expected arguments / callbacks / contraints. + + Mocked object. + Method. + List of all relevant expectation + + + + Gets the all expectations for proxy. + + Mocked object. + List of all relevant expectation + + + + Removes all the repeatable expectations for proxy. + + Mocked object. + + + + Replaces the old expectation with the new expectation for the specified proxy/method pair. + This replace ALL expectations that equal to old expectations. + + Proxy. + Method. + Old expectation. + New expectation. + + + + Adds the recorder and turn it into the active recorder. + + Recorder. + + + + Moves to previous recorder. + + + + + Gets the recorded expectation or null. + + + + + Gets the next expected calls string. + + + + + Moves to parent recorder. + + + + + Set the expectation so it can repeat any number of times. + + + + + Removes the expectation from the recorder + + + + + Clear the replayer to call (and all its chain of replayers) + This also removes it from the list of expectations, so it will never be considered again + + + + + Get the expectation for this method on this object with this arguments + + + + + Gets a value indicating whether this instance has expectations that weren't satisfied yet. + + + true if this instance has expectations; otherwise, false. + + + + + Allows to set various options for the last method call on + a specified object. + If the method has a return value, it's recommended to use Expect + + + + + Allows to get an interface to work on the last call. + + The mocked object + Interface that allows to set options for the last method call on this object + + + + Set the return value for the method. + + The object the method will return + IRepeat that defines how many times the method will return this value + + + + Set the return value for the method. This overload is needed for LastCall.Return(null) + + The object the method will return + IRepeat that defines how many times the method will return this value + + + + Throws the specified exception when the method is called. + + Exception to throw + + + + Ignores the arguments for this method. Any argument will be matched + againt this method. + + + + + Add constraints for the method's arguments. + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Set a callback method for the last call + + + + + Call the original method on the class, bypassing the mocking layers, for the last call. + + + + + Call the original method on the class, optionally bypassing the mocking layers, for the last call. + + + + + Set a delegate to be called when the expectation is matched. + The delegate return value will be returned from the expectation. + + + + + Gets an interface that will raise the last event when called. + + + + + Set the parameter values for out and ref parameters. + This is done using zero based indexing, and _ignoring_ any non out/ref parameter. + + + + + Documentation message for the expectation + + Message + + + + Use the property as a simple property, getting/setting the values without + causing mock expectations. + + + + + Better syntax to define repeats. + + + + + Base class for method recorders, handle delegating to inner recorder if needed. + + + + + List of the expected actions on for this recorder + The legal values are: + * Expectations + * Method Recorders + + + + + The current recorder. + + + + + The current replayer; + + + + + The parent recorder of this one, may be null. + + + + + This contains a list of all the replayers that should be ignored + for a spesific method call. A replayer gets into this list by calling + ClearReplayerToCall() on its parent. This list is Clear()ed on each new invocation. + + + + + All the repeatable methods calls. + + + + + Counts the recursion depth of the current expectation search stack + + + + + Creates a new instance. + + + + + Creates a new instance. + + Parent recorder. + Repeatable methods + + + + Records the specified call with the specified args on the mocked object. + + + + + Get the expectation for this method on this object with this arguments + + + + + Gets the all expectations for a mocked object and method combination, + regardless of the expected arguments / callbacks / contraints. + + Mocked object. + Method. + List of all relevant expectation + + + + Gets the all expectations for proxy. + + Mocked object. + List of all relevant expectation + + + + Replaces the old expectation with the new expectation for the specified proxy/method pair. + This replace ALL expectations that equal to old expectations. + + Proxy. + Method. + Old expectation. + New expectation. + + + + Remove the all repeatable expectations for proxy. + + Mocked object. + + + + Set the expectation so it can repeat any number of times. + + + + + Removes the expectation from the recorder + + + + + Adds the recorder and turn it into the active recorder. + + Recorder. + + + + Moves to previous recorder. + + + + + Moves to parent recorder. + + + + + Gets the recorded expectation or null. + + + + + Clear the replayer to call (and all its chain of replayers). + This also removes it from the list of expectations, so it will never be considered again + + + + + Get the expectation for this method on this object with this arguments + + + + + Gets the next expected calls string. + + + + + Handles the real getting of the recorded expectation or null. + + + + + Handle the real execution of this method for the derived class + + + + + Handle the real execution of this method for the derived class + + + + + Handle the real execution of this method for the derived class + + + + + Handle the real execution of this method for the derived class + + + + + Handle the real execution of this method for the derived class + + + + + Handle the real execution of this method for the derived class + + + + + Should this replayer be considered valid for this call? + + + + + This check the methods that were setup using the SetupResult.For() + or LastCall.Repeat.Any() and that bypass the whole expectation model. + + + + + Gets a value indicating whether this instance has expectations that weren't satisfied yet. + + + true if this instance has expectations; otherwise, false. + + + + + Handle the real execution of this method for the derived class + + + + + Ordered collection of methods, methods must arrive in specified order + in order to pass. + + + + + Unordered collection of method records, any expectation that exist + will be matched. + + + + + The parent recorder we have redirected to. + Useful for certain edge cases in orderring. + See: FieldProblem_Entropy for the details. + + + + + Creates a new instance. + + Parent recorder. + Repeatable methods + + + + Creates a new instance. + + + + + Records the specified call with the specified args on the mocked object. + + Mocked object. + Method. + Expectation. + + + + Get the expectation for this method on this object with this arguments + + Invocation for this method + Mocked object. + Method. + Args. + True is the call was recorded, false otherwise + + + + Gets the all expectations for a mocked object and method combination, + regardless of the expected arguments / callbacks / contraints. + + Mocked object. + Method. + List of all relevant expectation + + + + Gets the all expectations for proxy. + + Mocked object. + List of all relevant expectation + + + + Replaces the old expectation with the new expectation for the specified proxy/method pair. + This replace ALL expectations that equal to old expectations. + + Proxy. + Method. + Old expectation. + New expectation. + + + + Handle the real execution of this method for the derived class + + + + + Handles the real getting of the recorded expectation or null. + + + + + Handle the real execution of this method for the derived class + + + + + Gets the next expected calls string. + + + + + Create an exception for an unexpected method call. + + + + + Gets a value indicating whether this instance has expectations that weren't satisfied yet. + + + true if this instance has expectations; otherwise, false. + + + + + Creates a new instance. + + Parent recorder. + Repetable methods + + + + Creates a new instance. + + + + + Handles the real getting of the recorded expectation or null. + + + + + Get the expectation for this method on this object with this arguments + + + + + Gets the next expected calls string. + + + + + Hold an expectation for a method call on an object + + + + + Creates a new instance. + + Proxy. + Method. + Expectation. + + + + Determines if the object equal to this instance + + Obj. + + + + + Gets the hash code. + + + + + + Gets the proxy. + + + + + + Gets the method. + + + + + + Gets the expectation. + + + + + + Holds a pair of mocked object and a method + and allows to compare them against each other. + This allows us to have a distinction between mockOne.MyMethod() and + mockTwo.MyMethod()... + + + + + Creates a new instance. + + Proxy. + Method. + + + + Determines whatever obj equals to this instance. + ProxyMethodPairs are equal when they point to the same /instance/ of + an object, and to the same method. + + Obj. + + + + + Gets the hash code. + + + + + + Gets the proxy. + + + + + + Gets the method. + + + + + + Change the recorder from ordered to unordered and vice versa + + + + + Creates a new instance. + + + + + Disposes this instance. + + + + + Accessor for the current mocker + + + + + The current mocker + + + + + Used for [assembly: InternalsVisibleTo(RhinoMocks.StrongName)] + Used for [assembly: InternalsVisibleTo(RhinoMocks.NormalName)] + + + + + Strong name for the Dynamic Proxy assemblies. Used for InternalsVisibleTo specification. + + + + + Normal name for dynamic proxy assemblies. Used for InternalsVisibleTo specification. + + + + + Logs all method calls for methods + + + + + Setup method calls to repeat any number of times. + + + + + Get the method options and set the last method call to repeat + any number of times. + This also means that the method would transcend ordering + + + + + Get the method options for the last method call on the mockInstance and set it + to repeat any number of times. + This also means that the method would transcend ordering + + + + + Utility class for working with method calls. + + + + + Return the string representation of a method call and its arguments. + + The method + The method arguments + Invocation of the method, used to get the generics arguments + Delegate to format the parameter + The string representation of this method call + + + + Return the string representation of a method call and its arguments. + + The invocation of the method, used to get the generic parameters + The method + The method arguments + The string representation of this method call + + + + Delegate to format the argument for the string representation of + the method call. + + + + + Utility to get the default value for a type + + + + + The default value for a type. + Null for reference types and void + 0 for value types. + First element for enums + Note that we need to get the value even for opened generic types, such as those from + generic methods. + + Type. + The invocation. + the default value + + + + Allows easier access to MockRepository, works closely with Mocker.Current to + allow access to a context where the mock repository is automatially verified at + the end of the code block. + + + + + Initialize a code block where Mocker.Current is initialized. + At the end of the code block, all the expectation will be verified. + This overload will create a new MockRepository. + + The code that will be executed under the mock context + + + + Initialize a code block where Mocker.Current is initialized. + At the end of the code block, all the expectation will be verified. + This overload will create a new MockRepository. + + The mock repository to use, at the end of the code block, VerifyAll() will be called on the repository. + The code that will be executed under the mock context + + + + Create a FluentMocker + + The mock repository to use. + + + + A method with no arguments and no return value that will be called under the mock context. + + + + + FluentMocker implements some kind of fluent interface attempt + for saying "With the Mocks [mocks], Expecting (in same order) [things] verify [that]." + + + + + Interface to verify previously defined expectations + + + + + Verifies if a piece of code + + + + + Defines unordered expectations + + A delegate describing the expectations + an IMockVerifier + + + + Defines ordered expectations + + A delegate describing the expectations + an IMockVerifier + + + + Verifies previously defined expectations + + + + + This delegate is compatible with the System.Func{T,R} signature + We have to define our own to get compatability with 2.0 + + + + + This attribute is here so we can get better Pex integration + Using this means that Pex will not try to inspect the work of + the actual proxies being generated by Rhino Mocks + + + + diff --git a/src/umbraco.businesslogic/StateHelper.cs b/src/umbraco.businesslogic/StateHelper.cs index 10103cffdb..3884549f3f 100644 --- a/src/umbraco.businesslogic/StateHelper.cs +++ b/src/umbraco.businesslogic/StateHelper.cs @@ -9,7 +9,31 @@ namespace umbraco.BusinessLogic /// The StateHelper class provides general helper methods for handling sessions, context, viewstate and cookies. /// public class StateHelper - { + { + + private static HttpContextBase _httpContext; + + /// + /// Gets/sets the HttpContext object, this is generally used for unit testing. By default this will + /// use the HttpContext.Current + /// + internal static HttpContextBase HttpContext + { + get + { + if (_httpContext == null && System.Web.HttpContext.Current != null) + { + _httpContext = new HttpContextWrapper(System.Web.HttpContext.Current); + } + else if (_httpContext == null && System.Web.HttpContext.Current == null) + { + throw new NullReferenceException("The HttpContext property has not been set or the object execution is not running inside of an HttpContext"); + } + return _httpContext; + } + set { _httpContext = value; } + } + #region Session Helpers /// @@ -20,7 +44,7 @@ namespace umbraco.BusinessLogic /// public static T GetSessionValue(string key) { - return GetSessionValue(HttpContext.Current, key); + return GetSessionValue(HttpContext, key); } /// @@ -30,7 +54,20 @@ namespace umbraco.BusinessLogic /// The context. /// The key. /// + [Obsolete("Use the GetSessionValue accepting an HttpContextBase instead")] public static T GetSessionValue(HttpContext context, string key) + { + return GetSessionValue(new HttpContextWrapper(context), key); + } + + /// + /// Gets the session value. + /// + /// + /// The context. + /// The key. + /// + public static T GetSessionValue(HttpContextBase context, string key) { if (context == null) return default(T); @@ -47,7 +84,7 @@ namespace umbraco.BusinessLogic /// The value. public static void SetSessionValue(string key, object value) { - SetSessionValue(HttpContext.Current, key, value); + SetSessionValue(HttpContext, key, value); } /// @@ -56,7 +93,19 @@ namespace umbraco.BusinessLogic /// The context. /// The key. /// The value. + [Obsolete("Use the SetSessionValue accepting an HttpContextBase instead")] public static void SetSessionValue(HttpContext context, string key, object value) + { + SetSessionValue(new HttpContextWrapper(context), key, value); + } + + /// + /// Sets the session value. + /// + /// The context. + /// The key. + /// The value. + public static void SetSessionValue(HttpContextBase context, string key, object value) { if (context == null) return; @@ -75,7 +124,7 @@ namespace umbraco.BusinessLogic /// public static T GetContextValue(string key) { - return GetContextValue(HttpContext.Current, key); + return GetContextValue(HttpContext, key); } /// @@ -85,7 +134,20 @@ namespace umbraco.BusinessLogic /// The context. /// The key. /// + [Obsolete("Use the GetContextValue accepting an HttpContextBase instead")] public static T GetContextValue(HttpContext context, string key) + { + return GetContextValue(new HttpContextWrapper(context), key); + } + + /// + /// Gets the context value. + /// + /// + /// The context. + /// The key. + /// + public static T GetContextValue(HttpContextBase context, string key) { if (context == null) return default(T); @@ -102,7 +164,7 @@ namespace umbraco.BusinessLogic /// The value. public static void SetContextValue(string key, object value) { - SetContextValue(HttpContext.Current, key, value); + SetContextValue(HttpContext, key, value); } /// @@ -111,7 +173,19 @@ namespace umbraco.BusinessLogic /// The context. /// The key. /// The value. + [Obsolete("Use the SetContextValue accepting an HttpContextBase instead")] public static void SetContextValue(HttpContext context, string key, object value) + { + SetContextValue(new HttpContextWrapper(context), key, value); + } + + /// + /// Sets the context value. + /// + /// The context. + /// The key. + /// The value. + public static void SetContextValue(HttpContextBase context, string key, object value) { if (context == null) return; @@ -128,15 +202,15 @@ namespace umbraco.BusinessLogic /// private static StateBag GetStateBag() { - if (HttpContext.Current == null) - return null; + //if (HttpContext.Current == null) + // return null; - Page page = HttpContext.Current.CurrentHandler as Page; + var page = HttpContext.CurrentHandler as Page; if (page == null) return null; - Type pageType = typeof(Page); - PropertyInfo viewState = pageType.GetProperty("ViewState", BindingFlags.GetProperty | BindingFlags.Instance); + var pageType = typeof(Page); + var viewState = pageType.GetProperty("ViewState", BindingFlags.GetProperty | BindingFlags.Instance); if (viewState == null) return null; @@ -221,7 +295,7 @@ namespace umbraco.BusinessLogic { if (!Cookies.HasCookies) return null; - var cookie = HttpContext.Current.Request.Cookies[key]; + var cookie = HttpContext.Request.Cookies[key]; return cookie == null ? null : cookie.Value; } @@ -245,7 +319,7 @@ namespace umbraco.BusinessLogic { if (!Cookies.HasCookies) return; - var context = HttpContext.Current; + var context = HttpContext; HttpCookie cookie = new HttpCookie(key, value); cookie.Expires = DateTime.Now.AddDays(daysToPersist); @@ -282,7 +356,7 @@ namespace umbraco.BusinessLogic { get { - System.Web.HttpContext context = HttpContext.Current; + var context = HttpContext; // although just checking context should be enough?! // but in some (replaced) umbraco code, everything is checked... return context != null @@ -293,7 +367,7 @@ namespace umbraco.BusinessLogic public static void ClearAll() { - HttpContext.Current.Response.Cookies.Clear(); + HttpContext.Response.Cookies.Clear(); } public class Cookie @@ -402,14 +476,14 @@ namespace umbraco.BusinessLogic { // beware! will not clear browser's cookie // you probably want to use .Clear() - HttpContext.Current.Response.Cookies.Remove(_key); + HttpContext.Response.Cookies.Remove(_key); } public HttpCookie RequestCookie { get { - return HttpContext.Current.Request.Cookies[_key]; + return HttpContext.Request.Cookies[_key]; } } @@ -417,13 +491,13 @@ namespace umbraco.BusinessLogic { get { - return HttpContext.Current.Response.Cookies[_key]; + return HttpContext.Response.Cookies[_key]; } set { // .Set() ensures the uniqueness of cookies in the cookie collection // ie it is the same as .Remove() + .Add() -- .Add() allows duplicates - HttpContext.Current.Response.Cookies.Set(value); + HttpContext.Response.Cookies.Set(value); } } }