internal static void Check(Expect expect, int against)
{
try
{
Int32 convertedTest = Convert.ToInt32(expect.TestObject);
if(convertedTest > against)
{
if(expect.Reversed)
{
ThrowAboveException(expect, against);
}
}
else
{
if(!expect.Reversed)
{
ThrowNotAboveException(expect, against);
}
}
}
catch(InvalidCastException ex)
{
throw new Exception(String.Format("The object {0} ({1}) Could not be cast to a Int32", expect.TestObject, expect.Name), ex);
}
}
internal static void Check(Expect expect, Type type)
{
//If the object is null then unless the Type sent in is null then this has failed
if(expect.TestObject == null)
{
//This is a success
if(type == null)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was of type {2}", expect.TestObject, expect.Name, type));
}
}
}
else
{
if(expect.TestObject.GetType().Equals(type))//We have a matching type
{
if(expect.Reversed)//Return Exception if its reversed
{
throw new Exception(String.Format("The object {0} ({1}) was of type {2}", expect.TestObject, expect.Name, type));
}
}
else//We have different types
{
if(!expect.Reversed)//Return exception if its not reversed
{
throw new Exception(String.Format("The object {0} ({1}) was not of type {2}", expect.TestObject, expect.Name, type));
}
}
}
}
internal static void Check(Expect expect)
{
try
{
Action action = (Action)expect.TestObject;
if(action != null)
{
try
{
action.Invoke();
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) did not throw an exception", expect.TestObject, expect.Name));
}
}
catch(Exception ex)
{
if(expect.Reversed)
{
ThrowThrownException(expect, ex);
}
}
}
}
catch(InvalidCastException ex)
{
throw new Exception(String.Format("The object {0} ({1}) Could not be cast to an Action", expect.TestObject, expect.Name), ex);
}
}
internal static void Check(Expect expect, int against)
{
try
{
Int32 convertedTest = Convert.ToInt32(expect.TestObject);
if(convertedTest < against)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was below {2}", expect.TestObject, expect.Name, against));
}
}
else
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was above or equal to {2}", expect.TestObject, expect.Name, against));
}
}
}
catch(InvalidCastException ex)//Picking up on the invalid item
{
throw new Exception(String.Format("The object {0} ({1}) Could not be cast to a Int32", expect.TestObject, expect.Name), ex);
}
}
internal static void Check(Expect expect, int lower, int higher)
{
try
{
Int32 convertedTest = Convert.ToInt32(expect.TestObject);
if(convertedTest > lower && convertedTest < higher)
{
if(expect.Reversed)
{
ThrowInbetweenException(expect, lower, higher);
}
}
else
{
if(!expect.Reversed)
{
ThrowNotInbetweenException(expect, lower, higher);
}
}
}
catch(InvalidCastException ex)
{
throw new Exception(String.Format("The object {0} ({1}) Could not be cast to a In32", expect.TestObject, expect.Name), ex);
}
}
internal static void Check(Expect expect, double against)
{
try
{
Double convertedTest = Convert.ToDouble(expect.TestObject);
if(convertedTest > against || expect.TestObject.Equals(against))
{
if(expect.Reversed)
{
ThrowAboveException(expect, against);
}
}
else
{
if(!expect.Reversed)
{
ThrowBelowException(expect, against);
}
}
}
catch(InvalidCastException ex)
{
throw new Exception(String.Format("The object {0} ({1}) Could not be cast to a Double", expect.TestObject, expect.Name), ex);
}
}
/// <summary>
/// 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.
/// </summary>
/// <example>
/// IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
/// DoNotExpect.Call(delegate{ mockSrv.Stop(); });
/// ...
/// </example>
public static void Call(Expect.Action actionToExecute)
{
if (actionToExecute == null)
throw new ArgumentNullException("actionToExecute", "The action to execute cannot be null");
actionToExecute();
LastCall.Repeat.Never();
}
internal static void Check(Expect expect, int closeTo, int delta)
{
try
{
Int32 convertedTest = Convert.ToInt32(expect.TestObject);
if(convertedTest > (closeTo - delta) && convertedTest < (closeTo + delta))
{
if(expect.Reversed)
{
ThrowCloseToException(expect, closeTo);
}
}
else
{
if(!expect.Reversed)
{
ThrowNotCloseToException(expect, closeTo);
}
}
}
catch(InvalidCastException ex)
{
throw new Exception(String.Format("The object {0} ({1}) Could not be cast to a Int32", expect.TestObject, expect.Name), ex);
}
}
internal static void Check(Expect expect)
{
if(expect.TestObject == null)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was Null", expect.TestObject, expect.Name));
}
}
}
internal static void Check(Expect expect, Object against)
{
if(Object.Equals(expect.TestObject, against))//The items are equal
{
if(expect.Reversed)//Throw exception if reversed
{
throw new Exception(String.Format("The object {0} ({1}) was equal to {2}", expect.TestObject, expect.Name, against));
}
}
else//The items aren't equal
{
if(!expect.Reversed)//Throw exception if reversed
{
throw new Exception(String.Format("The object {0} ({1}) was not equal to {2}", expect.TestObject, expect.Name, against));
}
}
}
public void ShouldCreateTest()
{
AssemblyInformationFascade assemblyInformationFascade;
MockFactory mockFactory;
IReflectionFascade mockReflectionFascade;
Assembly mockAssembly, _unusedAssembly = null;
const string ASSEMBLY_TITLE = "sdfgsfdg";
const string ASSEMBLY_DESCRIPTION = "rthrs";
const string ASSEMBLY_PRODUCT = "hnfgnhfghn";
const string ASSEMBLY_COPYRIGHT = "bxcbx";
const string ASSEMBLY_COMPANY = "swergwerg";
const string ASSEMBLY_CONFIGURATION = "webxvxn";
const string ASSEMBLY_FILE_VERSION = "wegwegr";
const string ASSEMBLY_INFORMATIONAL_VERSION = "dnxnn";
const string ASSEMBLY_TRADEMARK = "yjtmrum";
mockFactory = new MockFactory();
mockReflectionFascade = mockFactory.CreateInstance <IReflectionFascade>();
mockAssembly = Assembly.GetEntryAssembly(); // dummy
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyTitleAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyTitleAttribute(ASSEMBLY_TITLE));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyDescriptionAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyDescriptionAttribute(ASSEMBLY_DESCRIPTION));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyProductAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyProductAttribute(ASSEMBLY_PRODUCT));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyCopyrightAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyCopyrightAttribute(ASSEMBLY_COPYRIGHT));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyCompanyAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyCompanyAttribute(ASSEMBLY_COMPANY));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyConfigurationAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyConfigurationAttribute(ASSEMBLY_CONFIGURATION));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyFileVersionAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyFileVersionAttribute(ASSEMBLY_FILE_VERSION));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyInformationalVersionAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyInformationalVersionAttribute(ASSEMBLY_INFORMATIONAL_VERSION));
Expect.On(mockReflectionFascade).One.Method(m => m.GetOneAttribute <AssemblyTrademarkAttribute>(_unusedAssembly)).With(mockAssembly).WillReturn(new AssemblyTrademarkAttribute(ASSEMBLY_TRADEMARK));
assemblyInformationFascade = new AssemblyInformationFascade(mockReflectionFascade, mockAssembly);
Assert.AreEqual(ASSEMBLY_TITLE, assemblyInformationFascade.Title);
Assert.AreEqual(ASSEMBLY_DESCRIPTION, assemblyInformationFascade.Description);
Assert.AreEqual(ASSEMBLY_PRODUCT, assemblyInformationFascade.Product);
Assert.AreEqual(ASSEMBLY_COPYRIGHT, assemblyInformationFascade.Copyright);
Assert.AreEqual(ASSEMBLY_COMPANY, assemblyInformationFascade.Company);
Assert.AreEqual(ASSEMBLY_CONFIGURATION, assemblyInformationFascade.Configuration);
Assert.AreEqual(ASSEMBLY_FILE_VERSION, assemblyInformationFascade.NativeFileVersion);
Assert.AreEqual(ASSEMBLY_INFORMATIONAL_VERSION, assemblyInformationFascade.InformationalVersion);
Assert.AreEqual(ASSEMBLY_TRADEMARK, assemblyInformationFascade.Trademark);
Assert.AreEqual(mockAssembly.GetName().Version.ToString(), assemblyInformationFascade.AssemblyVersion);
}
public void CanAssignNewTaskTest()
{
var newTask = new Task {
Name = "New task"
};
newTask.Tips.Add(new Tip {
Name = "Tip 0", SuspendTime = 0
});
newTask.Tips.Add(new Tip {
Name = "Tip 1", SuspendTime = 30
});
newTask.Tips.Add(new Tip {
Name = "Tip 2", SuspendTime = 60
});
Expect.Call(dispatcherFactory.CrearteDispatcher(game)).Return(taskDispatcher);
Expect.Call(taskDispatcher.GetNextTaskForTeam(null, null, null)).Return(newTask).IgnoreArguments();
Expect.Call(teamTaskStateRepository.SaveOrUpdate(null)).IgnoreArguments();
Expect.Call(acceptedTipRepository.SaveOrUpdate(null)).IgnoreArguments();
mocks.ReplayAll();
var service = new TaskService(taskRepository, teamTaskStateRepository, acceptedCodeRepository,
acceptedBadCodeRepository, acceptedTipRepository, dispatcherFactory);
var teamGameState = new TeamGameState {
Game = game, Team = team
};
var oldTask = new Task {
Name = "Old task"
};
var recalcDateTime = new DateTime(2011, 1, 1, 21, 0, 0);
service.AssignNewTask(teamGameState, oldTask, recalcDateTime);
mocks.VerifyAll();
Assert.AreEqual(newTask, teamGameState.ActiveTaskState.Task);
Assert.AreEqual(recalcDateTime, teamGameState.ActiveTaskState.TaskStartTime);
Assert.AreEqual(1, teamGameState.ActiveTaskState.AcceptedTips.Count());
Assert.AreEqual(0, teamGameState.AcceptedTasks.Count());
}
public void WhoAmITest()
{
//OutLineFormat("This test requires a gloo server to be running on port 9100 of the localhost", ConsoleColor.Yellow);
ConsoleLogger logger = new ConsoleLogger()
{
AddDetails = false
};
const string server = "localhost";// "int-heart.bamapps.net";
const int port = 80;
logger.StartLoggingThread();
ApplicationRegistrationRepository repo = ApplicationServiceRegistryContainer.GetServiceRegistry().Get <ApplicationRegistrationRepository>();
CoreClient client = new CoreClient("TestOrg", "TestApp", server, port, logger)
{
UseServiceSubdomains = false,
LocalCoreRegistryRepository = repo
};
client.InvocationException += (o, args) => logger.AddEntry("Invocation Exception: {0}", ((ServiceProxyInvokeEventArgs)args).Exception, args.PropertiesToString());
client.MethodInvoked += (o, args) => logger.AddEntry("ProxyClient Method Invoked: {0}", args.PropertiesToString());
CoreServiceResponse registrationResponse = client.RegisterClient();
Client current = Client.Of(client.LocalCoreRegistryRepository, client.ApplicationName, server, port);
CoreServiceResponse response = client.Connect();
string whoAmI = client.UserRegistryService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.ApplicationRegistryService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.ConfigurationService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.LoggerService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
whoAmI = client.DiagnosticService.WhoAmI();
Expect.AreEqual(current.ToString(), whoAmI);
Pass($"You are {whoAmI}");
}
public void SearchIntoMultipleFieldsTest()
{
IPagesStorageProviderV40 pagesStorageProvider = mocks.DynamicMock <IPagesStorageProviderV40>();
Expect.Call(pagesStorageProvider.CurrentWiki).Return("wiki1").Repeat.Any();
mocks.ReplayAll();
Collectors.InitCollectors();
Collectors.AddProvider(typeof(SqlServerIndexDirectoryProvider), System.Reflection.Assembly.GetAssembly(typeof(SqlServerIndexDirectoryProvider)), ConnString + InitialCatalog, typeof(IIndexDirectoryProviderV40));
Host.Instance = new Host();
Host.Instance.OverridePublicDirectory(testDir);
ProviderLoader.SetUp <IIndexDirectoryProviderV40>(typeof(SqlServerIndexDirectoryProvider), ConnString + InitialCatalog);
string pageTitle1 = "This is the title";
string pageContent1 = "This is the content of the page";
PageContent page1 = new PageContent("pagefullname1", pagesStorageProvider, DateTime.Now, pageTitle1,
"user-test", DateTime.Now, "comment to last editing", pageContent1, null, "Description of the page");
string pageTitle2 = "This is the title of the second page";
string pageContent2 = "This is the content of the second page";
PageContent page2 = new PageContent("pagefullname2", pagesStorageProvider, DateTime.Now, pageTitle2,
"user-test", DateTime.Now, "comment to last editing", pageContent2, null, "Description of the page");
Lucene.Net.Store.Directory directory = new RAMDirectory();
Assert.IsTrue(SearchClass.IndexPage(page1));
Assert.IsTrue(SearchClass.IndexPage(page2));
List <SearchResult> results = SearchClass.Search("wiki1", new SearchField[] { SearchField.Title, SearchField.Content }, "page", SearchOptions.AtLeastOneWord);
Assert.AreEqual(2, results.Count, "Wrong result length");
Assert.AreEqual(DocumentType.Page, results[1].DocumentType, "Wrong document type");
PageDocument doc1 = results[1].Document as PageDocument;
Assert.AreEqual(string.Empty, doc1.HighlightedTitle, "Wrong title");
Assert.AreEqual("This is the content of the <b class=\"searchkeyword\">page</b>", doc1.HighlightedContent, "Wrong content");
Assert.AreEqual(DocumentType.Page, results[0].DocumentType, "Wrong document type");
PageDocument doc2 = results[0].Document as PageDocument;
Assert.AreEqual("This is the title of the second <b class=\"searchkeyword\">page</b>", doc2.HighlightedTitle, "Wrong title");
Assert.AreEqual("This is the content of the second <b class=\"searchkeyword\">page</b>", doc2.HighlightedContent, "Wrong content");
}
public void List_FiveItemsAndPageSizeIs2AndCurrentPageIs3_ExpectViewResultWithCorrectPagingInfo()
{
// Arrange
const int Page = 3;
const int PageSize = 2;
const string totalCount = "5";
var fakeFizzBuzzEntries = new List <IFizzBuzzEntry>
{
GetFizzBuzzEntry(1),
GetFizzBuzzEntry(2),
GetFizzBuzzEntry(3),
GetFizzBuzzEntry(4),
GetFizzBuzzEntry(5),
};
var fizzBuzzRepository = this.mocks.StrictMock <IFizzBuzzRepository>();
Expect.Call(fizzBuzzRepository.Get(5)).Return(fakeFizzBuzzEntries);
this.mocks.ReplayAll();
var controller = new HomeController(fizzBuzzRepository);
controller.PageSize = PageSize;
// Act
ViewResult result = controller.List(totalCount, Page) as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.ViewData);
var viewModel = result.ViewData.Model as FizzBuzzViewModel;
Assert.IsNotNull(viewModel);
Assert.IsNotNull(viewModel.PagingInfo);
Assert.AreEqual(viewModel.PagingInfo.CurrentPage, Page);
Assert.AreEqual(viewModel.PagingInfo.ItemsPerPage, PageSize);
Assert.AreEqual(viewModel.PagingInfo.TotalItems, fakeFizzBuzzEntries.Count);
Assert.AreEqual(viewModel.PagingInfo.TotalPages, 3);
}
public void CachedSessionTwoRequests()
{
IConnectionFactory connectionFactory = (IConnectionFactory)mocks.CreateMock(typeof(IConnectionFactory));
IConnection connection = new TestConnection();
Expect.Call(connectionFactory.CreateConnection()).Return(connection).Repeat.Once();
mocks.ReplayAll();
CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
cachingConnectionFactory.TargetConnectionFactory = connectionFactory;
IConnection con1 = cachingConnectionFactory.CreateConnection();
ISession session1 = con1.CreateSession(AcknowledgementMode.Transactional);
TestSession testSession1 = GetTestSession(session1);
Assert.AreEqual(1, testSession1.CreatedCount);
Assert.AreEqual(0, testSession1.CloseCount);
//will create a new one, not in the cache.
ISession session2 = con1.CreateSession(AcknowledgementMode.Transactional);
TestSession testSession2 = GetTestSession(session2);
Assert.AreEqual(1, testSession2.CreatedCount);
Assert.AreEqual(0, testSession2.CloseCount);
Assert.AreNotSame(testSession1, testSession2);
Assert.AreNotSame(session1, session2);
session1.Close(); // will be put in the cache
ISession session3 = con1.CreateSession(AcknowledgementMode.Transactional);
TestSession testSession3 = GetTestSession(session3);
Assert.AreSame(testSession1, testSession3);
Assert.AreSame(session1, session3);
Assert.AreEqual(1, testSession1.CreatedCount);
Assert.AreEqual(0, testSession1.CloseCount);
mocks.VerifyAll();
}
public void CompressionJournalGetsLatestPropertyValue()
{
Log.DebugOut = true;
AutoResetEvent blocker = new AutoResetEvent(false);
DataReplicationTestClass value = GetRandomDataInstance();
Journal journal = GetCompressionJournal <Journal>();
journal.Logger = new ConsoleLogger();
bool?checkedJournal = false;
journal.Enqueue(value, (jes) => jes.Each(je =>
{
Message.PrintLine("Fully flushed called", ConsoleColor.DarkBlue);
checkedJournal = true;
Expect.AreSame(journal, je.Journal);
blocker.Set();
}));
for (int i = 0; i < 100; i++)
{
Thread.Sleep(30);
Message.PrintLine("QueueLength={0}", ConsoleColor.Cyan, journal.QueueLength.ToString());
Message.PrintLine("Flushed status: {0}", ConsoleColor.Yellow, journal.QueueFlusher.ThreadState.ToString());
}
if (!blocker.WaitOne(15000))
{
Warn("Inconclusive, blocker was not set");
}
checkedJournal.Value.IsTrue();
string newAddress = "Updated " + 8.RandomLetters();
value.Address = newAddress;
journal.Enqueue(value, (jes) =>
{
DataReplicationTestClass check = journal.LoadInstance <DataReplicationTestClass>(value.Id);
Expect.AreEqual(newAddress, check.Address);
OutLine(check.Address);
blocker.Set();
});
if (!blocker.WaitOne(15000))
{
Warn("Inconclusive, blocker was not set");
}
}
public void ScreensShouldBeCached()
{
var mocks = new MockRepository();
var mockApplication = mocks.StrictMock <Application>();
var window = mocks.StrictMock <DummyWindow>();
SetupResult.For(window.IsClosed).Return(false);
Expect.Call(mockApplication.GetWindow("dummy", InitializeOption.NoCache)).Return(window).IgnoreArguments();
var applicationSession = mocks.StrictMock <ApplicationSession>();
SetupResult.For(applicationSession.Application).Return(mockApplication);
mocks.ReplayAll();
var screenRepository = new ScreenRepository(applicationSession);
Assert.AreSame(GetScreen(screenRepository), GetScreen(screenRepository));
mocks.VerifyAll();
}
public void GetObject_ViaTargetObjectNameWithNestedPropertyPath()
{
Expect.Call(mockFactory.IsSingleton("foo")).Return(true);
TestObject target = new TestObject("Fiona Apple", 28);
target.Spouse = target;
Expect.Call(mockFactory.GetObject("foo")).Return(target);
mocks.ReplayAll();
PropertyPathFactoryObject fac = new PropertyPathFactoryObject();
fac.TargetObjectName = "foo";
fac.PropertyPath = "spouse.name";
fac.ObjectFactory = mockFactory;
string name = (string)fac.GetObject();
Assert.AreEqual("Fiona Apple", name);
mocks.VerifyAll();
}
public void Can_execute_TransactionalFlush_specifying_isolation_level()
{
var tx = _mocks.CreateMock <ITransaction>();
var session = _mocks.DynamicMock <ISession>();
SetupResult.For(session.BeginTransaction(IsolationLevel.Serializable)).Return(tx);
_uow = _mocks.PartialMock <UnitOfWorkImplementor>(_factory, session);
using (_mocks.Record())
{
Expect.Call(tx.Commit);
Expect.Call(tx.Dispose);
}
using (_mocks.Playback())
{
_uow.TransactionalFlush(IsolationLevel.Serializable);
}
}
public static void AddForeignKeyShouldIncrementReferencingFKsForTargetTable()
{
TestSchemaManager tsm = new TestSchemaManager();
string ingTable = "referencing";
string edTable = "referred";
Table referencing = new Table {
Name = ingTable
};
Table referred = new Table {
Name = edTable
};
int initial = referred.ReferencingForeignKeys.Length;
ForeignKeyColumn fk = new ForeignKeyColumn("referredId", ingTable, edTable);
tsm.TestAddForeignKey(referencing, referred, fk);
Expect.AreEqual(initial + 1, referred.ReferencingForeignKeys.Length);
Expect.AreEqual(0, referencing.ReferencingForeignKeys.Length);
}
public void DaoCrudCreateTest()
{
(_testDatabases.Count > 0).ShouldBeTrue();
string methodName = MethodBase.GetCurrentMethod().Name;
_testDatabases.Each(db =>
{
Message.PrintLine("{0}.{1}: {2}", ConsoleColor.DarkYellow, this.GetType().Name, methodName, db.GetType().Name);
TestTable test = new TestTable(db)
{
Name = 8.RandomLetters()
};
test.Save(db);
Expect.IsGreaterThan(test.Id.Value, 0, "Id should have been greater than 0");
Message.PrintLine("{0}", ConsoleColor.Cyan, test.PropertiesToString());
});
}
public void ReadRequestResponse_ConnectionAbortedWhileReadingMessageFrame()
{
MockRepository mocks = new MockRepository();
var mockTransport = mocks.StrictMock <IStreamResource>(null);
byte[] mbapHeader = { 45, 63, 0, 0, 0, 6 };
Expect.Call(mockTransport.Read(new byte[6], 0, 6)).Do(((Func <byte[], int, int, int>) delegate(byte[] buf, int offset, int count)
{
Array.Copy(mbapHeader, buf, 6);
return(6);
}));
Expect.Call(mockTransport.Read(new byte[6], 0, 6)).Return(0);
mocks.ReplayAll();
ModbusIpTransport.ReadRequestResponse(mockTransport);
mocks.VerifyAll();
}
public void Reset()
{
LogManager.Reset();
Assert.IsInstanceOf <DefaultConfigurationReader>(LogManager.ConfigurationReader);
Assert.Throws <ArgumentNullException>(delegate { LogManager.Reset(null); });
IConfigurationReader r = mocks.StrictMock <IConfigurationReader>();
using (mocks.Record())
{
Expect.Call(r.GetSection(LogManager.COMMON_LOGGING_SECTION)).Return(new TraceLoggerFactoryAdapter());
}
using (mocks.Playback())
{
LogManager.Reset(r);
Assert.IsInstanceOf <TraceLoggerFactoryAdapter>(LogManager.Adapter);
}
}
internal static void Check(Expect expect, Object contains)
{
//Check to see if we can respond to 'contains' method
if(expect.TestObject != null)
{
try
{
Type type = expect.TestObject.GetType();
MethodInfo info = type.GetMethod("Contains");
if(info != null)
{
Boolean result = (Boolean)info.Invoke(expect.TestObject, new object[]{ contains });
if(result)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) did not contain {2}", expect.TestObject, expect.Name, contains));
}
}
else
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) contained {2}", expect.TestObject, expect.Name, contains));
}
}
}
else
{
throw new Exception(String.Format("The object {0} ({1}) could not be be checked if it contains {2}", expect.TestObject, expect.Name, contains));
}
}
catch(AmbiguousMatchException ex)
{
ex.ToString();
throw new Exception(String.Format("The object {0} ({1}) could not be be checked if it contains {2}", expect.TestObject, expect.Name, contains));
}
}
else
{
throw new Exception(String.Format("The object {0} ({1}) was null and thus could not be be checked if it contains {2}", expect.TestObject, expect.Name, contains));
}
}
public void DoesNotChokeOnBadResourceLocationIfIgnoreBadResourcesFlagSetToTrue()
{
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.IgnoreResourceNotFound = true;
IResource mockResource = (IResource)mocks.CreateMock(typeof(IResource));
Expect.Call(mockResource.Exists).Return(false);
cfg.Location = mockResource;
cfg.ConfigSections = new string[] { "" };
IConfigurableListableObjectFactory mockFactory = (IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory));
Expect.Call(mockFactory.GetObjectDefinitionNames()).Return(new string[] {});
mocks.ReplayAll();
cfg.PostProcessObjectFactory(mockFactory);
mocks.VerifyAll();
}
public void InspectContextForUniqueNoncePasses()
{
var repository = new MockRepository();
var nonceStore = repository.StrictMock <INonceStore>();
var context = new OAuthContext {
Nonce = "2"
};
using (repository.Record())
{
Expect.Call(nonceStore.RecordNonceAndCheckIsUnique(context, "2")).Return(true);
}
using (repository.Playback())
{
var inspector = new NonceStoreInspector(nonceStore);
inspector.InspectContext(ProviderPhase.GrantRequestToken, context);
}
}
public void Can_get_a_dto_from_an_entity()
{
var entity = new Dog()
{
Id = 1, Age = 10, Name = "New Dog"
};
var expected = new DogDto()
{
Id = 1, Age = 10, Name = "New Dog"
};
Expect.Call(_instancePlugin.Translate <Dog, DogDto>(entity)).Return(expected);
_mockery.ReplayAll();
var actual = Mechanisms.Translation.Translate.This(entity).Into <DogDto>();
_mockery.VerifyAll();
}
public void VisitNewExpression_ChangedArguments_WithMembers()
{
NewExpression expression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new Expression[] { Expression.Constant(0) },
typeof(TypeForNewExpression).GetProperty("A"));
var newArguments = new List <Expression> {
Expression.Constant(214578)
}.AsReadOnly();
Expect.Call(VisitorMock.VisitAndConvert(expression.Arguments, "VisitNewExpression")).Return(newArguments);
var result = (NewExpression)InvokeAndCheckVisitExpression("VisitNewExpression", expression);
Assert.That(result, Is.Not.SameAs(expression));
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.New));
Assert.That(result.Arguments, Is.EqualTo(newArguments));
Assert.That(result.Members, Is.SameAs(expression.Members));
}
public static void ConditionalExpressionThrowsException()
{
Database database = new SQLiteDatabase(".\\", MethodBase.GetCurrentMethod().Name);
ConsoleLogger logger = PrepareDatabaseAndGetLogger(database);
DaoExpressionFilter f = new DaoExpressionFilter(logger);
bool thrown = false;
try
{
Out(f.Where <TestTable>((t) => t.Name == "blah" || t.Name == "monkey").Parse(), ConsoleColor.DarkCyan);
}
catch (ExpressionTypeNotSupportedException etnse)
{
thrown = true;
Out(etnse.Message, ConsoleColor.Cyan);
}
Expect.IsTrue(thrown);
}
public void TransactionRollbackOnly()
{
IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection));
ISessionFactory sessionFactory = (ISessionFactory)mocks.CreateMock(typeof(ISessionFactory));
ISession session = (ISession)mocks.CreateMock(typeof(ISession));
ITransaction transaction = (ITransaction)mocks.CreateMock(typeof(ITransaction));
IDbTransaction adoTransaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction));
using (mocks.Ordered())
{
Expect.Call(sessionFactory.OpenSession()).Return(session);
Expect.Call(session.Connection).Return(connection);
Expect.Call(session.BeginTransaction(IsolationLevel.ReadCommitted)).Return(transaction);
Expect.Call(session.IsOpen).Return(true);
Expect.Call(session.FlushMode).Return(FlushMode.Auto);
session.Flush();
LastCall.On(session).Repeat.Once();
Expect.Call(adoTransaction.Connection).Return(connection);
LastCall.On(adoTransaction).Repeat.Once();
transaction.Rollback();
LastCall.On(transaction).Repeat.Once();
Expect.Call(session.Close()).Return(null);
}
mocks.ReplayAll();
TestableHibernateTransactionManager tm = new TestableHibernateTransactionManager(sessionFactory);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
tm.StubbedTransactionThatReturnsExpectedConnection = adoTransaction;
TransactionTemplate tt = new TransactionTemplate(tm);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(sessionFactory), "Shouldn't have a thread session");
tt.Execute(new TransactionRollbackOnlyTxCallback(sessionFactory));
Assert.IsFalse(TransactionSynchronizationManager.HasResource(sessionFactory), "Shouldn't have a thread session");
mocks.VerifyAll();
}
public void ParticipatingTransactionWithWithNotSupported()
{
IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection));
ISessionFactory sessionFactory = (ISessionFactory)mocks.CreateMock(typeof(ISessionFactory));
ISession session = (ISession)mocks.CreateMock(typeof(ISession));
ITransaction transaction = (ITransaction)mocks.CreateMock(typeof(ITransaction));
//using (mocks.Ordered())
//{
Expect.Call(sessionFactory.OpenSession()).Return(session).Repeat.Twice();
Expect.Call(session.Connection).Return(connection);
Expect.Call(session.BeginTransaction(IsolationLevel.ReadCommitted)).Return(transaction);
Expect.Call(session.IsOpen).Return(true);
Expect.Call(session.FlushMode).Return(FlushMode.Auto).Repeat.Twice();
session.Flush();
LastCall.On(session).Repeat.Twice();
transaction.Commit();
LastCall.On(transaction).Repeat.Once();
#if NH_2_0
Expect.Call(session.Close()).Return(null).Repeat.Once();
#else
Expect.Call(session.Close()).Return(null).Repeat.Twice();
#endif
//}
mocks.ReplayAll();
HibernateTransactionManager tm = new HibernateTransactionManager(sessionFactory);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
tt.PropagationBehavior = TransactionPropagation.RequiresNew;
Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session");
tt.Execute(new ParticipatingTransactionWithWithNotSupportedTxCallback(tt, sessionFactory));
Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session");
mocks.VerifyAll();
}
public void UnicastMessage_TimeoutException()
{
MockRepository mocks = new MockRepository();
ModbusTransport transport = mocks.PartialMock <ModbusTransport>();
transport.Write(null);
LastCall.IgnoreArguments().Repeat.Times(Modbus.DefaultRetries + 1);
Expect.Call(transport.ReadResponse <ReadCoilsInputsResponse>())
.Do((ThrowExceptionDelegate) delegate { throw new TimeoutException(); })
.Repeat.Times(Modbus.DefaultRetries + 1);
mocks.ReplayAll();
ReadCoilsInputsRequest request = new ReadCoilsInputsRequest(Modbus.ReadInputs, 2, 3, 4);
transport.UnicastMessage <ReadCoilsInputsResponse>(request);
mocks.VerifyAll();
}
public void ShouldBeAbleToUseInvokeAsync()
{
AsyncProxyableEcho testObj = GetTestAsyncProxyable();
AutoResetEvent blocker = new AutoResetEvent(false);
string value = "this is a value: ".RandomString(8);
bool? ran = false;
testObj.InvokeAsync(r =>
{
ran = true;
Expect.AreEqual(value, r.Result);
blocker.Set();
}, "Send", value);
blocker.WaitOne(1000 * 60 * 3);
StopServers();
Expect.IsTrue(ran.Value);
}
public void Execute()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock <ISolrConnection>();
var parameters = new ExtractParameters(null, "1", "text.doc");
With.Mocks(mocks).Expecting(() => {
Expect.Call(conn.PostStream("/update/extract", null, null, new List <KeyValuePair <string, string> > {
KV("literal.id", parameters.Id),
KV("resource.name", parameters.ResourceName),
}))
.Repeat.Once()
.Return("");
})
.Verify(() => {
var cmd = new ExtractCommand(new ExtractParameters(null, "1", "text.doc"));
cmd.Execute(conn);
});
}
public void GetTypes_WithTypeDiscoveryService_GetsTypeInheritingMixinFromBase()
{
Expect.Call(_serviceProvider.GetService(typeof(ITypeDiscoveryService))).Return(_typeDiscoveryService);
Expect.Call(_typeDiscoveryService.GetTypes(typeof(object), true))
.Return(
new object[]
{
typeof(DerivedBusinessObjectClassWithoutAttribute)
});
_mockRepository.ReplayAll();
var finder = new BindableObjectTypeFinder(_serviceProvider);
List <Type> types = finder.GetTypes(false);
Assert.That(types, Is.EquivalentTo(new[] { typeof(DerivedBusinessObjectClassWithoutAttribute) }));
_mockRepository.VerifyAll();
}
public void SessionEndShouldEndSession()
{
string userName = MethodBase.GetCurrentMethod().Name;
IHttpContext context;
LoginResponse result;
UserManager userMgr;
UserTestTools.SignUpAndLogin(userName, out context, out result, out userMgr);
Session session = Session.Get(context);
session.End();
Expect.IsFalse(session.IsActive.Value);
Session doubleCheck = Session.OneWhere(c => c.Id == session.Id.Value);
Expect.IsFalse(doubleCheck.IsActive.Value, "Doublecheck was still active");
}
public void ShowModalButtonShouldInvokeControllerShowModal()
{
controller = mockRepository.DynamicMock <IAppController>();
using (mockRepository.Record())
{
Expect.
On(controller).
Call(controller.GetData()).
Return(TestValue);
}
using (mockRepository.Playback())
{
alternateAppForm = new AlternateAppForm(controller);
alternateAppForm.Show();
ButtonTester button = new ButtonTester("showModalButton");
button.Click();
}
}
public static void SetNewSchemaShouldThrowExceptionIfSchemaExists()
{
SchemaManager mgr = new SchemaManager();
mgr.SetSchema("test");
bool thrown = false;
try
{
mgr.SetNewSchema("test");
}
catch (Exception ex)
{
thrown = true;
TryDeleteSchema(mgr.SetSchema("test"));
}
Expect.IsTrue(thrown);
}
private void FailsTestIfMethodExpectedBetweenNAndMTimesAndCalledMoreThanMTimes(Mock <IParentInterface> mock)
{
mock.Expects.Between(N, M).Method(_ => _.MethodVoid());
for (int i = 0; i < M; i++)
{
mock.MockObject.MethodVoid();
}
//do one more than M
Expect.That(mock.MockObject.MethodVoid).Throws <UnexpectedInvocationException>(new StringContainsMatcher(string.Format(@"
Unexpected invocation of:
System.Void {0}.MethodVoid()
MockFactory Expectations:
System.Void {0}.MethodVoid() [EXPECTED: 10 to 20 times CALLED: 21 times]
", mock.Name)));
mock.ClearExpectations();
}
public void AssociationsAreMade()
{
DynamicTypeManager mgr = new DynamicTypeManager(new DynamicTypeDataRepository(), DataSettings.Default);
DynamicNamespaceDescriptor ns = new DynamicNamespaceDescriptor {
Namespace = $"Test.Name.Space.{nameof(AssociationsAreMade)}"
};
ns = mgr.DynamicTypeDataRepository.Save(ns);
DynamicTypeDescriptor typeDescriptor = new DynamicTypeDescriptor {
DynamicNamespaceDescriptorId = ns.Id
};
Expect.IsNull(typeDescriptor.DynamicNamespaceDescriptor);
typeDescriptor = mgr.DynamicTypeDataRepository.Save(typeDescriptor);
Expect.IsNotNull(typeDescriptor.DynamicNamespaceDescriptor);
Expect.AreEqual(ns, typeDescriptor.DynamicNamespaceDescriptor);
}
internal static void Check(Expect expect)
{
if(expect.TestObject == null)
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was not Ok", expect.TestObject, expect.Name));
}
}
else
{
Type type = expect.TestObject.GetType();
//Any value type is marked as 'existing'
if(type.IsValueType)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) exists", expect.TestObject, expect.Name));
}
}
else
{
if(expect.TestObject != null)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) exists", expect.TestObject, expect.Name));
}
}
else
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) doesn't exist", expect.TestObject, expect.Name));
}
}
}
}
}
//Pre process if count can be used
public Count(Expect expect)
: base(expect)
{
ParseCountMethod();
}
public To(Expect expect)
: base(expect)
{
}
//Pre process if Length can be used
public Length(Expect expect)
: base(expect)
{
ParseLengthMethod();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="expect"></param>
public ExpectationReached(Expect expect)
: base(expect)
{
Message = "Expectation reached : " + Expect.Expectation.Name;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="expect">the expectation which changed</param>
/// <param name="newState">the new expectation state</param>
/// <param name="prevState">the previous expectation state</param>
/// <param name="message">the message associated to this expectation state change</param>
public ExpectationStateChange(Expect expect)
: base("Expectation state change", expect.Expectation)
{
Expect = expect;
}
/// <summary>
/// Sets the start time to the next day.
/// </summary>
public void NewDay()
{
_startTime = _startTime.AddDays(1);
_newDay = true;
_expectedTime = Expect.Start;
_lastTime = 0;
_nextDay = false;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="expect"></param>
public FailedExpectation(Expect expect)
: base(expect)
{
Message = "Failed expectation : " + Expect.Expectation.Name;
}
public ToNot(Expect expect)
: base(expect)
{
Expect.Reversed = !Expect.Reversed;
}
internal static void ThrowNotAboveException(Expect expect, Object against)
{
throw new Exception(String.Format("The object {0} ({1}) was below or equal to {2}", expect.TestObject, expect.Name, against));
}
/// <summary>
/// Checks and adjusts the start and end times for a program.
/// </summary>
/// <param name="guideData">The guide data.</param>
/// <returns>true if successfull otherwise false</returns>
public bool CheckAdjustTime(ref ProgramData guideData)
{
WorldDateTime guideStartTime = guideData.StartTime;
WorldDateTime guideEndTime = guideData.EndTime;
_addDays = 1;
// Check if the start time day value is set
if (guideStartTime.Day == 0)
{
guideStartTime.Day = _startTime.Day; // Set program day to start day
}
else
{
// program has day value
if (guideStartTime.Day != _startTime.Day && _expectedTime != Expect.Start)
{
// day value not the same as start time -> increase start time one day
_grabDay++;
_startTime = _startTime.AddDays(1);
_nextDay = false;
_lastTime = 0;
_expectedTime = Expect.BeforeMidday;
}
}
// Check and set month and year
if (guideStartTime.Year == 0)
{
guideStartTime.Year = _startTime.Year;
}
if (guideStartTime.Month == 0)
{
guideStartTime.Month = _startTime.Month;
}
// State loop Start, BeforeMidday and AfterMidday
switch (_expectedTime)
{
// Start of a new day - need to work out if the listings start in the morning or afternoon
case Expect.Start:
if (OnPerviousDay(guideStartTime.Hour))
{
return false; // Guide starts on pervious day ignore these listings.
}
if (_newDay)
{
_newDay = false;
//if (guideStartTime.Hour < _startTime.Hour)
// return false;
if (guideStartTime.Hour <= 12)
{
_expectedTime = Expect.BeforeMidday;
goto case Expect.BeforeMidday;
}
_expectedTime = Expect.AfterMidday;
goto case Expect.AfterMidday;
}
_expectedTime = Expect.BeforeMidday;
goto case Expect.BeforeMidday; // Pass into BeforeMidday Code
// Before Midday
case Expect.BeforeMidday:
if (_lastTime > guideStartTime.Hour)
{
// last time was before midday, new time is less -> site doesn't have 24 hours or AM/PM
_expectedTime = Expect.AfterMidday;
}
else
{
if (guideStartTime.Hour <= 12)
{
break; // Time is before midday -> Do nothing
}
}
// Pass into AfterMidday Code
goto case Expect.AfterMidday;
// After midday
case Expect.AfterMidday:
bool adjusted = false;
if (guideStartTime.Hour < 12) // Site doesn't have correct time
{
guideStartTime.Hour += 12; // starts again at 1:00 without "pm"
adjusted = true;
}
if (_lastTime > guideStartTime.Hour)
{
if (_nextDay)
{
_addDays++;
_grabDay++;
_startTime = _startTime.AddDays(1);
}
else
{
_nextDay = true;
}
if (adjusted)
{
guideStartTime.Hour -= 12;
}
if (guideStartTime.Hour < 12)
{
_expectedTime = Expect.BeforeMidday;
}
}
break;
default:
break;
}
// store current hour as last hour
_lastTime = guideStartTime.Hour;
// Check if orogram has an end time
if (guideEndTime != null)
{
// set Day, Month and Year is not set
if (guideEndTime.Year == 0)
{
guideEndTime.Year = guideStartTime.Year;
}
if (guideEndTime.Month == 0)
{
guideEndTime.Month = guideStartTime.Month;
}
if (guideEndTime.Day == 0)
{
guideEndTime.Day = guideStartTime.Day;
}
// correct date if required
if (_nextDay)
{
if (guideStartTime.Hour > guideEndTime.Hour)
{
// start before midnight end after
guideEndTime = guideEndTime.AddDays(_addDays + 1);
}
else
{
guideEndTime = guideEndTime.AddDays(_addDays);
}
}
else
{
if (guideStartTime.Hour > guideEndTime.Hour)
{
guideEndTime = guideEndTime.AddDays(_addDays);
}
}
}
// if next day -> correct start date
if (_nextDay)
{
guideStartTime = guideStartTime.AddDays(_addDays);
}
//Log.Debug("WebEPG: Guide, Program Debug: [{0} {1}]", _GrabDay, _bNextDay);
guideData.StartTime = guideStartTime;
guideData.EndTime = guideEndTime;
return true;
}
internal static void ThrowNotInbetweenException(Expect expect, Object lower, Object higher)
{
throw new Exception(String.Format("The object {0} ({1}) was not inbetween {2} and {3}", expect.TestObject, expect.Name, lower, higher));
}
public A(Expect expect)
: base(expect)
{
}
// public static void UpdateBadNames(string name)
// {
// string oldNames = Settings.Get("badNames", string.Empty);
// Settings.Add("badNames", oldNames + name + " ");
// }
#region Private methods
private static bool DoIsValidName(string name, Expect start)
{
Expect expect = start;
int upperCount = 0;
if (name.StartsWith(".ctor") || name.StartsWith("op_"))
return true;
if (name == "<Module>")
return true;
if (name == "value__") // used by enums
return true;
if (name.Length > 0 && name[0] == '$')
return true;
// leading and trailing underscores are never ok
if (name.Length > 0 && name[0] == '_')
return false;
if (name.Length > 1 && name[name.Length - 1] == '_')
return false;
if (DoIsHungarian(name))
return false;
for (int i = 0; i < name.Length; ++i)
{
switch (expect)
{
case Expect.Upper:
if (!char.IsUpper(name[i]))
return false;
++upperCount;
expect = Expect.Lower;
break;
case Expect.Lower:
if (!char.IsLower(name[i]))
{
if (++upperCount > 3 || i == 0) // need to allow stuff like ValidIOMask
return false;
}
else
{
upperCount = 0;
expect = Expect.Any;
}
break;
case Expect.Any:
if (char.IsUpper(name[i]))
{
expect = Expect.Lower;
upperCount = 1;
}
else if (name[i] == '_')
return false;
break;
}
}
return true;
}
public Be(Expect expect)
: base(expect)
{
}
public Chain(Expect expect)
{
Expect = expect;
}
public NotTo(Expect expect)
: base(expect)
{
}
internal static void ThrowThrownException(Expect expect, Exception ex)
{
throw new Exception(String.Format("The object {0} ({1}) threw an exception", expect.TestObject, expect.Name));
}
internal static void Check(Expect expect)
{
if(expect.TestObject == null)
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was not Ok", expect.TestObject, expect.Name));
}
}
else
{
Type type = expect.TestObject.GetType();
/*
* We need to check to see if we have a value type in order to see how to check for 'ok'.
* For value types we will attempt to conver them to a bool in order to see if the
*/
if(type.IsValueType)
{
try
{
if(Convert.ToBoolean(expect.TestObject))
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was Ok", expect.TestObject, expect.Name));
}
}
else
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was not Ok", expect.TestObject, expect.Name));
}
}
}
catch(InvalidCastException ex)//Picking up on the invalid item
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was not Ok, threw internal exception {2}", expect.TestObject, expect.Name, ex.Message));
}
}
}
else
{
if(expect.TestObject != null)
{
if(expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was Ok", expect.TestObject, expect.Name));
}
}
else
{
if(!expect.Reversed)
{
throw new Exception(String.Format("The object {0} ({1}) was not Ok", expect.TestObject, expect.Name));
}
}
}
}
}
