public void CopySettingsStorageProviderData() { var mocks = new MockRepository(); var source = mocks.StrictMock <ISettingsStorageProviderV30>(); var destination = mocks.StrictMock <ISettingsStorageProviderV30>(); var sourceAclManager = mocks.StrictMock <IAclManager>(); var destinationAclManager = mocks.StrictMock <IAclManager>(); // Setup SOURCE --------------------- // Settings var settings = new Dictionary <string, string> { { "Set1", "Value1" }, { "Set2", "Value2" } }; Expect.Call(source.GetAllSettings()).Return(settings); // Meta-data (global) Expect.Call(source.GetMetaDataItem(MetaDataItem.AccountActivationMessage, null)).Return("AAM"); Expect.Call(source.GetMetaDataItem(MetaDataItem.PasswordResetProcedureMessage, null)).Return("PRM"); Expect.Call(source.GetMetaDataItem(MetaDataItem.LoginNotice, null)).Return(""); Expect.Call(source.GetMetaDataItem(MetaDataItem.PageChangeMessage, null)).Return("PCM"); Expect.Call(source.GetMetaDataItem(MetaDataItem.DiscussionChangeMessage, null)).Return("DCM"); // Meta-data (root) Expect.Call(source.GetMetaDataItem(MetaDataItem.EditNotice, null)).Return(""); Expect.Call(source.GetMetaDataItem(MetaDataItem.Footer, null)).Return("FOOT"); Expect.Call(source.GetMetaDataItem(MetaDataItem.Header, null)).Return("HEADER"); Expect.Call(source.GetMetaDataItem(MetaDataItem.HtmlHead, null)).Return("HTML"); Expect.Call(source.GetMetaDataItem(MetaDataItem.PageFooter, null)).Return("P_FOOT"); Expect.Call(source.GetMetaDataItem(MetaDataItem.PageHeader, null)).Return("P_HEADER"); Expect.Call(source.GetMetaDataItem(MetaDataItem.Sidebar, null)).Return("SIDEBAR"); // Meta-data ("NS" namespace) Expect.Call(source.GetMetaDataItem(MetaDataItem.EditNotice, "NS")).Return("NS_EDIT"); Expect.Call(source.GetMetaDataItem(MetaDataItem.Footer, "NS")).Return("NS_FOOT"); Expect.Call(source.GetMetaDataItem(MetaDataItem.Header, "NS")).Return("NS_HEADER"); Expect.Call(source.GetMetaDataItem(MetaDataItem.HtmlHead, "NS")).Return("NS_HTML"); Expect.Call(source.GetMetaDataItem(MetaDataItem.PageFooter, "NS")).Return("NS_P_FOOT"); Expect.Call(source.GetMetaDataItem(MetaDataItem.PageHeader, "NS")).Return("NS_P_HEADER"); Expect.Call(source.GetMetaDataItem(MetaDataItem.Sidebar, "NS")).Return("NS_SIDEBAR"); // Plugin assemblies byte[] asm1 = { 1, 2, 3, 4, 5 }; byte[] asm2 = { 6, 7, 8, 9, 10, 11, 12 }; Expect.Call(source.ListPluginAssemblies()).Return(new[] { "Plugins1.dll", "Plugins2.dll" }); Expect.Call(source.RetrievePluginAssembly("Plugins1.dll")).Return(asm1); Expect.Call(source.RetrievePluginAssembly("Plugins2.dll")).Return(asm2); // Plugin status Expect.Call(source.GetPluginStatus("Test1.Plugin1")).Return(true); Expect.Call(source.GetPluginStatus("Test2.Plugin2")).Return(false); // Plugin config Expect.Call(source.GetPluginConfiguration("Test1.Plugin1")).Return("Config1"); Expect.Call(source.GetPluginConfiguration("Test2.Plugin2")).Return(""); // Outgoing links var outgoingLinks = new Dictionary <string, string[]> { { "Page1", new[] { "Page2", "Page3" } }, { "Page2", new[] { "Page3" } }, { "Page3", new[] { "Page4", "Page3" } } }; Expect.Call(source.GetAllOutgoingLinks()).Return(outgoingLinks); // ACLs Expect.Call(source.AclManager).Return(sourceAclManager); AclEntry[] entries = { new AclEntry("Res1", "Act1", "Subj1", Value.Grant), new AclEntry("Res2", "Act2", "Subj2", Value.Deny) }; Expect.Call(sourceAclManager.RetrieveAllEntries()).Return(entries); // Setup DESTINATION ----------------- // Settings destination.BeginBulkUpdate(); LastCall.On(destination).Repeat.Once(); foreach (var pair in settings) { Expect.Call(destination.SetSetting(pair.Key, pair.Value)).Return(true); } destination.EndBulkUpdate(); LastCall.On(destination).Repeat.Once(); // Meta-data (global) Expect.Call(destination.SetMetaDataItem(MetaDataItem.AccountActivationMessage, null, "AAM")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.PasswordResetProcedureMessage, null, "PRM")) .Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.LoginNotice, null, "")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.PageChangeMessage, null, "PCM")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.DiscussionChangeMessage, null, "DCM")).Return(true); // Meta-data (root) Expect.Call(destination.SetMetaDataItem(MetaDataItem.EditNotice, null, "")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.Footer, null, "FOOT")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.Header, null, "HEADER")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.HtmlHead, null, "HTML")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.PageFooter, null, "P_FOOT")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.PageHeader, null, "P_HEADER")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.Sidebar, null, "SIDEBAR")).Return(true); // Meta-data ("NS" namespace) Expect.Call(destination.SetMetaDataItem(MetaDataItem.EditNotice, "NS", "NS_EDIT")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.Footer, "NS", "NS_FOOT")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.Header, "NS", "NS_HEADER")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.HtmlHead, "NS", "NS_HTML")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.PageFooter, "NS", "NS_P_FOOT")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.PageHeader, "NS", "NS_P_HEADER")).Return(true); Expect.Call(destination.SetMetaDataItem(MetaDataItem.Sidebar, "NS", "NS_SIDEBAR")).Return(true); // Plugin assemblies Expect.Call(destination.StorePluginAssembly("Plugins1.dll", asm1)).Return(true); Expect.Call(destination.StorePluginAssembly("Plugins2.dll", asm2)).Return(true); // Plugin status Expect.Call(destination.SetPluginStatus("Test1.Plugin1", true)).Return(true); Expect.Call(destination.SetPluginStatus("Test2.Plugin2", false)).Return(true); // Plugin config Expect.Call(destination.SetPluginConfiguration("Test1.Plugin1", "Config1")).Return(true); Expect.Call(destination.SetPluginConfiguration("Test2.Plugin2", "")).Return(true); // Outgoing links foreach (var pair in outgoingLinks) { Expect.Call(destination.StoreOutgoingLinks(pair.Key, pair.Value)).Return(true); } // ACLs Expect.Call(destination.AclManager).Return(destinationAclManager).Repeat.Any(); foreach (var e in entries) { Expect.Call(destinationAclManager.StoreEntry(e.Resource, e.Action, e.Subject, e.Value)).Return(true); } mocks.ReplayAll(); DataMigrator.CopySettingsStorageProviderData(source, destination, new[] { "NS" }, new[] { "Test1.Plugin1", "Test2.Plugin2" }); mocks.VerifyAll(); }
public void SessionCallbackWithinSynchronizedTransaction() { SingleConnectionFactory scf = new SingleConnectionFactory(mockConnectionFactory); EmsTemplate template = CreateTemplate(); template.ConnectionFactory = scf; mockConnection.Start(); LastCall.On(mockConnection).Repeat.Times(2); Expect.Call(mockSession.Transacted).Return(UseTransactedSession).Repeat.Twice(); if (UseTransactedTemplate) { mockSession.Commit(); LastCall.On(mockSession).Repeat.Once(); } mockSession.Close(); LastCall.On(mockSession).Repeat.Once(); mockConnection.Stop(); LastCall.On(mockConnection).Repeat.Once(); mockConnection.Close(); LastCall.On(mockConnection).Repeat.Once(); mocks.ReplayAll(); TransactionSynchronizationManager.InitSynchronization(); try { template.Execute(delegate(ISession session) { bool b = session.Transacted; return(null); }); template.Execute(delegate(ISession session) { bool b = session.Transacted; return(null); }); Assert.AreSame(mockSession, ConnectionFactoryUtils.GetTransactionalSession(scf, null, false)); Assert.AreSame(mockSession, ConnectionFactoryUtils.GetTransactionalSession(scf, scf.CreateConnection(), false)); //In Java this test was doing 'double-duty' and testing TransactionAwareConnectionFactoryProxy, which has //not been implemented in .NET template.Execute(delegate(ISession session) { bool b = session.Transacted; return(null); }); IList synchs = TransactionSynchronizationManager.Synchronizations; Assert.AreEqual(1, synchs.Count); ITransactionSynchronization synch = (ITransactionSynchronization)synchs[0]; synch.BeforeCommit(false); synch.BeforeCompletion(); synch.AfterCommit(); synch.AfterCompletion(TransactionSynchronizationStatus.Unknown); } finally { TransactionSynchronizationManager.ClearSynchronization(); //Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0); //Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive); scf.Dispose(); } Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0); mocks.VerifyAll(); }
public void TransactionCommit() { IDbProvider provider = mocks.StrictMock <IDbProvider>(); IDbConnection connection = mocks.StrictMock <IDbConnection>(); ISessionFactory sessionFactory = mocks.StrictMock <ISessionFactory>(); ISession session = mocks.StrictMock <ISession>(); ITransaction transaction = mocks.StrictMock <ITransaction>(); IQuery query = mocks.StrictMock <IQuery>(); IList list = new ArrayList(); list.Add("test"); using (mocks.Ordered()) { Expect.Call(sessionFactory.OpenSession()).Return(session); Expect.Call(session.Connection).Return(connection); Expect.Call(session.BeginTransaction(IsolationLevel.Serializable)).Return(transaction); Expect.Call(session.IsOpen).Return(true); Expect.Call(session.CreateQuery("some query string")).Return(query); Expect.Call(query.List()).Return(list); transaction.Commit(); LastCall.On(transaction).Repeat.Once(); Expect.Call(session.Close()).Return(null); } mocks.ReplayAll(); LocalSessionFactoryObjectStub lsfo = new LocalSessionFactoryObjectStub(sessionFactory); lsfo.AfterPropertiesSet(); ISessionFactory sfProxy = lsfo.GetObject() as ISessionFactory; Assert.IsNotNull(sfProxy); HibernateTransactionManager tm = new HibernateTransactionManager(); tm.TransactionSynchronization = TransactionSynchronizationState.Always; tm.AdoExceptionTranslator = new FallbackExceptionTranslator(); tm.SessionFactory = sfProxy; tm.DbProvider = provider; TransactionTemplate tt = new TransactionTemplate(tm); tt.TransactionIsolationLevel = IsolationLevel.Serializable; Assert.IsFalse(TransactionSynchronizationManager.HasResource(sfProxy), "Hasn't thread session"); Assert.IsFalse(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive, "Actual transaction not active"); object result = tt.Execute(new TransactionCommitTxCallback(sfProxy, provider)); Assert.IsTrue(result == list, "Incorrect result list"); Assert.IsFalse(TransactionSynchronizationManager.HasResource(sfProxy), "Hasn't thread session"); Assert.IsFalse(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive, "Actual transaction not active"); mocks.VerifyAll(); }
public void MigrateFilesStorageProviderData() { var mocks = new MockRepository(); var source = mocks.StrictMock <IFilesStorageProviderV30>(); var destination = mocks.StrictMock <IFilesStorageProviderV30>(); var settingsProvider = mocks.StrictMock <ISettingsStorageProviderV30>(); var aclManager = mocks.StrictMock <IAclManager>(); Expect.Call(settingsProvider.AclManager).Return(aclManager).Repeat.Any(); // Setup SOURCE ----------------- // Directories Expect.Call(source.ListDirectories("/")).Return(new[] { "/Dir1/", "/Dir2/" }); Expect.Call(source.ListDirectories("/Dir1/")).Return(new[] { "/Dir1/Sub/" }); Expect.Call(source.ListDirectories("/Dir2/")).Return(new string[0]); Expect.Call(source.ListDirectories("/Dir1/Sub/")).Return(new string[0]); // Settings (permissions) Expect.Call(aclManager.RenameResource( Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(source, "/"), Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(destination, "/"))) .Return(true); Expect.Call(aclManager.RenameResource( Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(source, "/Dir1/"), Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(destination, "/Dir1/"))) .Return(true); Expect.Call(aclManager.RenameResource( Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(source, "/Dir2/"), Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(destination, "/Dir2/"))) .Return(true); Expect.Call(aclManager.RenameResource( Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(source, "/Dir1/Sub/"), Actions.ForDirectories.ResourceMasterPrefix + AuthTools.GetDirectoryName(destination, "/Dir1/Sub/"))) .Return(true); // Filenames Expect.Call(source.ListFiles("/")).Return(new[] { "/File1.txt", "/File2.txt" }); Expect.Call(source.ListFiles("/Dir1/")).Return(new[] { "/Dir1/File.txt" }); Expect.Call(source.ListFiles("/Dir2/")).Return(new string[0]); Expect.Call(source.ListFiles("/Dir1/Sub/")).Return(new[] { "/Dir1/Sub/File.txt" }); // File content Expect.Call(source.RetrieveFile("/File1.txt", null, false)).Constraints( RMC.Is.Equal("/File1.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do( new RetrieveFile( delegate(string file, Stream stream, bool count) { var stuff = Encoding.Unicode.GetBytes("content1"); stream.Write(stuff, 0, stuff.Length); return(true); })); Expect.Call(source.RetrieveFile("/File2.txt", null, false)).Constraints( RMC.Is.Equal("/File2.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do( new RetrieveFile( delegate(string file, Stream stream, bool count) { var stuff = Encoding.Unicode.GetBytes("content2"); stream.Write(stuff, 0, stuff.Length); return(true); })); Expect.Call(source.RetrieveFile("/Dir1/File.txt", null, false)).Constraints( RMC.Is.Equal("/Dir1/File.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do( new RetrieveFile( delegate(string file, Stream stream, bool count) { var stuff = Encoding.Unicode.GetBytes("content3"); stream.Write(stuff, 0, stuff.Length); return(true); })); Expect.Call(source.RetrieveFile("/Dir1/Sub/File.txt", null, false)).Constraints( RMC.Is.Equal("/Dir1/Sub/File.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do( new RetrieveFile( delegate(string file, Stream stream, bool count) { var stuff = Encoding.Unicode.GetBytes("content4"); stream.Write(stuff, 0, stuff.Length); return(true); })); // File details Expect.Call(source.GetFileDetails("/File1.txt")).Return(new FileDetails(8, DateTime.Now, 52)); Expect.Call(source.GetFileDetails("/File2.txt")).Return(new FileDetails(8, DateTime.Now, 0)); Expect.Call(source.GetFileDetails("/Dir1/File.txt")).Return(new FileDetails(8, DateTime.Now, 21)); Expect.Call(source.GetFileDetails("/Dir1/Sub/File.txt")).Return(new FileDetails(8, DateTime.Now, 123)); // Page attachments Expect.Call(source.GetPagesWithAttachments()).Return(new[] { "MainPage", "Sub.Page", "Sub.Another" }); Expect.Call(source.ListPageAttachments(null)) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "MainPage"); })) .Return(new[] { "Attachment.txt" }); Expect.Call(source.ListPageAttachments(null)) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Page"); })) .Return(new[] { "Attachment2.txt" }); Expect.Call(source.ListPageAttachments(null)) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Another"); })) .Return(new string[0]); // Page attachment content Expect.Call(source.RetrievePageAttachment(null, "Attachment.txt", null, false)).Constraints( RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "MainPage"); }), RMC.Is.Equal("Attachment.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do( new RetrieveAttachment( delegate(PageInfo page, string name, Stream stream, bool count) { var stuff = Encoding.Unicode.GetBytes("content5"); stream.Write(stuff, 0, stuff.Length); return(true); })); Expect.Call(source.RetrievePageAttachment(null, "Attachment2.txt", null, false)).Constraints( RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Page"); }), RMC.Is.Equal("Attachment2.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do( new RetrieveAttachment( delegate(PageInfo page, string name, Stream stream, bool count) { var stuff = Encoding.Unicode.GetBytes("content6"); stream.Write(stuff, 0, stuff.Length); return(true); })); // Attachment details Expect.Call(source.GetPageAttachmentDetails(null, "Attachment.txt")).Constraints( RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "MainPage"); }), RMC.Is.Equal("Attachment.txt")).Return(new FileDetails(8, DateTime.Now, 8)); Expect.Call(source.GetPageAttachmentDetails(null, "Attachment2.txt")).Constraints( RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Page"); }), RMC.Is.Equal("Attachment2.txt")).Return(new FileDetails(8, DateTime.Now, 29)); // Setup DESTINATION ------------------------ // Directories Expect.Call(destination.CreateDirectory("/", "Dir1")).Return(true); Expect.Call(destination.CreateDirectory("/", "Dir2")).Return(true); Expect.Call(destination.CreateDirectory("/Dir1/", "Sub")).Return(true); // Files Expect.Call(destination.StoreFile("/File1.txt", null, false)).Constraints( RMC.Is.Equal("/File1.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do(new StoreFile( delegate(string name, Stream stream, bool overwrite) { var buff = new byte[512]; var read = stream.Read(buff, 0, (int)stream.Length); Assert.AreEqual("content1", Encoding.Unicode.GetString(buff, 0, read), "Wrong data"); return(true); })); Expect.Call(destination.StoreFile("/File2.txt", null, false)).Constraints( RMC.Is.Equal("/File2.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do(new StoreFile( delegate(string name, Stream stream, bool overwrite) { var buff = new byte[512]; var read = stream.Read(buff, 0, (int)stream.Length); Assert.AreEqual("content2", Encoding.Unicode.GetString(buff, 0, read), "Wrong data"); return(true); })); Expect.Call(destination.StoreFile("/Dir1/File.txt", null, false)).Constraints( RMC.Is.Equal("/Dir1/File.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do(new StoreFile( delegate(string name, Stream stream, bool overwrite) { var buff = new byte[512]; var read = stream.Read(buff, 0, (int)stream.Length); Assert.AreEqual("content3", Encoding.Unicode.GetString(buff, 0, read), "Wrong data"); return(true); })); Expect.Call(destination.StoreFile("/Dir1/Sub/File.txt", null, false)).Constraints( RMC.Is.Equal("/Dir1/Sub/File.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do(new StoreFile( delegate(string name, Stream stream, bool overwrite) { var buff = new byte[512]; var read = stream.Read(buff, 0, (int)stream.Length); Assert.AreEqual("content4", Encoding.Unicode.GetString(buff, 0, read), "Wrong data"); return(true); })); // File retrieval count destination.SetFileRetrievalCount("/File1.txt", 52); LastCall.On(destination).Repeat.Once(); destination.SetFileRetrievalCount("/File2.txt", 0); LastCall.On(destination).Repeat.Once(); destination.SetFileRetrievalCount("/Dir1/File.txt", 21); LastCall.On(destination).Repeat.Once(); destination.SetFileRetrievalCount("/Dir1/Sub/File.txt", 123); LastCall.On(destination).Repeat.Once(); // Page attachments Expect.Call(destination.StorePageAttachment(null, "Attachment.txt", null, false)).Constraints( RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "MainPage"); }), RMC.Is.Equal("Attachment.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do(new StoreAttachment( delegate(PageInfo page, string name, Stream stream, bool overwrite) { var buff = new byte[512]; var read = stream.Read(buff, 0, (int)stream.Length); Assert.AreEqual("content5", Encoding.Unicode.GetString(buff, 0, read), "Wrong data"); return(true); })); Expect.Call(destination.StorePageAttachment(null, "Attachment2.txt", null, false)).Constraints( RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Page"); }), RMC.Is.Equal("Attachment2.txt"), RMC.Is.TypeOf <Stream>(), RMC.Is.Equal(false)).Do(new StoreAttachment( delegate(PageInfo page, string name, Stream stream, bool overwrite) { var buff = new byte[512]; var read = stream.Read(buff, 0, (int)stream.Length); Assert.AreEqual("content6", Encoding.Unicode.GetString(buff, 0, read), "Wrong data"); return(true); })); // Attachment retrieval count destination.SetPageAttachmentRetrievalCount(null, "Attachment.txt", 8); LastCall.On(destination) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "MainPage"); }), RMC.Is.Equal("Attachment.txt"), RMC.Is.Equal(8)) .Repeat.Once(); destination.SetPageAttachmentRetrievalCount(null, "Attachment2.txt", 29); LastCall.On(destination) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Page"); }), RMC.Is.Equal("Attachment2.txt"), RMC.Is.Equal(29)) .Repeat.Once(); // Delete source content Expect.Call(source.DeleteFile("/File1.txt")).Return(true); Expect.Call(source.DeleteFile("/File2.txt")).Return(true); Expect.Call(source.DeleteDirectory("/Dir1/")).Return(true); Expect.Call(source.DeleteDirectory("/Dir2/")).Return(true); Expect.Call(source.DeletePageAttachment(null, "Attachment.aspx")) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "MainPage"); }), RMC.Is.Equal("Attachment.txt")) .Return(true); Expect.Call(source.DeletePageAttachment(null, "Attachment2.aspx")) .Constraints(RMC.Is.Matching(delegate(PageInfo p) { return(p.FullName == "Sub.Page"); }), RMC.Is.Equal("Attachment2.txt")) .Return(true); mocks.Replay(source); mocks.Replay(destination); mocks.Replay(settingsProvider); mocks.Replay(aclManager); DataMigrator.MigrateFilesStorageProviderData(source, destination, settingsProvider); mocks.Verify(source); mocks.Verify(destination); mocks.Verify(settingsProvider); mocks.Verify(aclManager); }
public void TransactionWithPropagationSupportsAndInnerTransaction() { IDbConnection connection = mocks.StrictMock <IDbConnection>(); ISessionFactory sessionFactory = mocks.StrictMock <ISessionFactory>(); ISession session1 = mocks.StrictMock <ISession>(); ISession session2 = mocks.StrictMock <ISession>(); ITransaction transaction = mocks.StrictMock <ITransaction>(); Expect.Call(sessionFactory.OpenSession()).Return(session1); Expect.Call(session1.Connection).Return(connection); Expect.Call(session1.SessionFactory).Return(sessionFactory); Expect.Call(session1.FlushMode).Return(FlushMode.Auto).Repeat.Twice(); session1.Flush(); LastCall.IgnoreArguments().Repeat.Twice(); Expect.Call(session1.Close()).Return(null); Expect.Call(sessionFactory.OpenSession()).Return(session2); Expect.Call(session2.Connection).Return(connection).Repeat.Twice(); Expect.Call(session2.BeginTransaction(IsolationLevel.ReadCommitted)).Return(transaction); Expect.Call(session2.FlushMode).Return(FlushMode.Auto); session2.Flush(); LastCall.IgnoreArguments(); Expect.Call(session2.IsOpen).Return(true); transaction.Commit(); LastCall.On(transaction).Repeat.Once(); Expect.Call(session2.Close()).Return(null); mocks.ReplayAll(); LocalSessionFactoryObjectStub lsfo = new LocalSessionFactoryObjectStub(sessionFactory); lsfo.AfterPropertiesSet(); ISessionFactory sfProxy = (ISessionFactory)lsfo.GetObject(); Assert.IsNotNull(sfProxy); HibernateTransactionManager tm = new HibernateTransactionManager(sessionFactory); tm.TransactionSynchronization = TransactionSynchronizationState.Always; TransactionTemplate tt = new TransactionTemplate(tm); tt.PropagationBehavior = TransactionPropagation.Supports; TransactionTemplate tt2 = new TransactionTemplate(tm); tt2.PropagationBehavior = TransactionPropagation.Required; HibernateTemplate ht = new HibernateTemplate(sessionFactory); ht.TemplateFlushMode = TemplateFlushMode.Eager; ht.ExposeNativeSession = true; Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session"); tt.Execute(new TransactionWithPropagationSupportsAndInnerTransactionTxCallback(tt2, sessionFactory, ht, session1, session2)); Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session"); mocks.ReplayAll(); }
/// <summary> /// Does the test transaction commit with flush failure. /// </summary> /// <param name="fallbackTranslation">if set to <c>true</c> if the exception throw /// is of the type NHibernate.ADOException, in which case HibernateTransactionManager /// will 'fallback' to using the error codes in the underlying exception thrown by /// the provider, ie. a SqlException, MySqlException. Otherwise, if it is /// another subclass of HibernateException, then perform a direct maping as /// found in SessionFactoryUtils.ConvertHibernateAccessException.</param> private void DoTransactionCommitWithFlushFailure(bool fallbackTranslation) { #region Mock Setup IDbProvider provider = new TestDbProvider(); IDbConnection connection = mocks.StrictMock <IDbConnection>(); ISessionFactory sessionFactory = mocks.StrictMock <ISessionFactory>(); ISession session = mocks.StrictMock <ISession>(); ITransaction transaction = mocks.StrictMock <ITransaction>(); IDbTransaction adoTransaction = mocks.StrictMock <IDbTransaction>(); Exception rootCause = null; 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); transaction.Commit(); Exception sqlException = new TestSqlException("mymsg", "2627"); if (fallbackTranslation) { //error code 2627 will map to a DataAccessIntegrity exception in sqlserver, which is the metadata //used by TestDbProvider. rootCause = sqlException; LastCall.On(transaction).Throw(new ADOException("mymsg", sqlException)); } else { rootCause = new PropertyValueException("mymsg", typeof(string).Name, "Name"); LastCall.On(transaction).Throw(rootCause); } Expect.Call(adoTransaction.Connection).Return(connection); LastCall.On(adoTransaction).Repeat.Once(); transaction.Rollback(); LastCall.On(transaction).Repeat.Once(); Expect.Call(session.Close()).Return(null); } #endregion mocks.ReplayAll(); TestableHibernateTransactionManager tm = new TestableHibernateTransactionManager(sessionFactory); tm.TransactionSynchronization = TransactionSynchronizationState.Always; tm.DbProvider = provider; tm.StubbedTransactionThatReturnsExpectedConnection = adoTransaction; TransactionTemplate tt = new TransactionTemplate(tm); Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session"); Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); IList list = new ArrayList(); list.Add("test"); try { tt.Execute(new TransactionCommitWithFlushFailureCallback(sessionFactory, list)); Assert.Fail("Should have thrown DataIntegrityViolationException"); } catch (DataIntegrityViolationException ex) { Assert.AreEqual(rootCause, ex.InnerException); Assert.IsTrue(ex.Message.IndexOf("mymsg") != -1); } Assert.IsTrue(!TransactionSynchronizationManager.HasResource(sessionFactory), "Hasn't thread session"); Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); mocks.VerifyAll(); }
public void CallingLastCallWithoutHavingLastCallThrows() { Assert.Throws <InvalidOperationException>( "There is no matching last call on this object. Are you sure that the last call was a virtual or interface method call?", () => LastCall.On(demo)); }
public void ReturnDerivedType() { demo.EnumNoArgs(); LastCall.On(demo).Return(DemoEnum.Demo); }
public void DifferentArgumentsFromMethodThrows() { demo.VoidThreeArgs(0, "", 0f); Assert.Throws <InvalidOperationException>("Callback arguments didn't match the method arguments", () => LastCall.On(demo).Callback <int, string, string>(OtherThreeArgs)); }
public void Test_04_NegativeTest_MockLogger() { MockRepository mocks = new MockRepository(); ILogger logger = mocks.CreateMock <ILogger>(); logger.TestStart(null, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); // S E T U P logger.TestStageStart(TestStage.Setup, DateTime.Now); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStageEnd(TestStage.Setup, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); // E X E C U T E logger.TestStageStart(TestStage.Execution, DateTime.Now); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStepStart(null, DateTime.Now, true, true); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStepEnd(null, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStepStart(null, DateTime.Now, true, true); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.Log(LogLevel.INFO, null); LastCall.On(logger).Repeat.Any().IgnoreArguments(); logger.LogData(null, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.ValidatorStart(null, DateTime.Now); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.Log(LogLevel.INFO, null); LastCall.On(logger).Repeat.Any().IgnoreArguments(); logger.Log(LogLevel.ERROR, null, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.LogException(null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.ValidatorEnd(null, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStepEnd(null, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStageEnd(TestStage.Execution, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); // C L E A N U P logger.TestStageStart(TestStage.Cleanup, DateTime.Now); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStepStart(null, DateTime.Now, true, true); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStepEnd(null, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestStageEnd(TestStage.Cleanup, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.TestEnd(null, DateTime.Now, null); LastCall.On(logger).Repeat.Once().IgnoreArguments(); logger.Flush(); logger.Close(); mocks.ReplayAll(); Context ctx = new Context(logger); BizUnit bizUnit = new BizUnit(@"..\..\..\Test\BizUnit.Tests\TestCases\Test_04_NegativeTest.xml", ctx); try { bizUnit.RunTest(); } catch (Exception) {} mocks.VerifyAll(); }
public void MediaPropertiesMustChangeOnlyAfterUpdate() { MockRepository rep = new MockRepository(); IFileSystem fs = rep.CreateMock <IFileSystem>(); MyFileStream stm = rep.CreateMock <MyFileStream>(rep); Expect.Call(fs.OpenFile("test")).Return(stm); DateTime time1 = new DateTime(2000, 1, 1); long size1 = 100; Expect.Call(stm.Length).Repeat.Any().Return(size1); Expect.Call(stm.LastWriteTime).Repeat.Any().Return(time1); Expect.Call(stm.IsDeleted).Repeat.Any().Return(false); rep.ReplayAll(); using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test"))) { // Media properties are the same as stm's ones Assert.AreEqual(time1, media.LastModified); Assert.AreEqual(size1, media.Size); rep.VerifyAll(); rep.BackToRecordAll(); // Chnage the properties of stm DateTime time2 = new DateTime(2000, 2, 2); long size2 = 200; Expect.Call(stm.Length).Repeat.Any().Return(size2); Expect.Call(stm.LastWriteTime).Repeat.Any().Return(time2); Expect.Call(stm.IsDeleted).Repeat.Any().Return(false); rep.ReplayAll(); // Properties have not still changed Assert.AreEqual(time1, media.LastModified); Assert.AreEqual(size1, media.Size); // This Update should refresh media's properties media.Update(); Assert.AreEqual(time2, media.LastModified); Assert.AreEqual(size2, media.Size); // Subsequent calls change nothing media.Update(); media.Update(); Assert.AreEqual(time2, media.LastModified); Assert.AreEqual(size2, media.Size); rep.VerifyAll(); rep.BackToRecordAll(); stm.Dispose(); LastCall.On(stm).Repeat.AtLeastOnce(); rep.ReplayAll(); } rep.VerifyAll(); }
public void FileDeletedByAnotherProcessAndThenNewFileAppeared() { MockRepository rep = new MockRepository(); IFileSystem fs = rep.CreateMock <IFileSystem>(); // Create and init the first stream long initialSize1 = 100; DateTime modifTime1 = new DateTime(2000, 3, 4); MyFileStream stm1 = rep.CreateMock <MyFileStream>(rep); Expect.Call(stm1.Length).Repeat.Any().Return(initialSize1); Expect.Call(stm1.IsDeleted).Repeat.Any().Return(false); Expect.Call(stm1.LastWriteTime).Repeat.Any().Return(modifTime1); // Instruct file system to return the first stream Expect.Call(fs.OpenFile("test")).Return(stm1); rep.ReplayAll(); using (SimpleFileMedia media = new SimpleFileMedia(fs, SimpleFileMedia.CreateConnectionParamsFromFileName("test"))) { // Check that media refers to the first stream stm1 Assert.AreEqual(initialSize1, media.DataStream.Length); Assert.AreEqual(initialSize1, media.Size); Assert.AreEqual(true, media.IsAvailable); rep.VerifyAll(); rep.BackToRecordAll(); // Simulate file deletion: Length and LastWriteTime keep returning file properties, // but IsDeleted now returns "true". Expect.Call(stm1.Length).Repeat.Any().Return(initialSize1); Expect.Call(stm1.LastWriteTime).Repeat.Any().Return(modifTime1); Expect.Call(stm1.IsDeleted).Repeat.Any().Return(true); // We expect stream stm1 to be released/disposed stm1.Dispose(); LastCall.On(stm1).Repeat.AtLeastOnce(); // Factory cannot open the file that has been deleted while being locked Expect.Call(fs.OpenFile("test")).Repeat.Any().Throw(new UnauthorizedAccessException()); rep.ReplayAll(); // Properties must return previous values as long as Update is not called Assert.AreEqual(initialSize1, media.Size); Assert.AreEqual(initialSize1, media.DataStream.Length); Assert.AreEqual(true, media.IsAvailable); // This update should detect file deletion and release it media.Update(); Assert.AreEqual(0, media.Size); Assert.AreEqual(0, media.DataStream.Length); Assert.AreEqual(false, media.IsAvailable); // Subsequent Updates should change nothing media.Update(); media.Update(); Assert.AreEqual(0, media.Size); Assert.AreEqual(0, media.DataStream.Length); Assert.AreEqual(false, media.IsAvailable); rep.VerifyAll(); rep.BackToRecordAll(); // Simulate that new file with name "test" appeared long initialSize2 = 200; DateTime modifTime2 = new DateTime(2000, 4, 5); MyFileStream stm2 = rep.CreateMock <MyFileStream>(rep); Expect.Call(stm2.Length).Repeat.Any().Return(initialSize2); Expect.Call(stm2.IsDeleted).Repeat.Any().Return(false); Expect.Call(stm2.LastWriteTime).Repeat.Any().Return(modifTime2); stm2.Dispose(); LastCall.On(stm2).Repeat.AtLeastOnce(); Expect.Call(fs.OpenFile("test")).Return(stm2); rep.ReplayAll(); // Properties must return previous values as long as Update is not called Assert.AreEqual(0, media.Size); Assert.AreEqual(0, media.DataStream.Length); Assert.AreEqual(false, media.IsAvailable); // This Update will pick up new file media.Update(); Assert.AreEqual(initialSize2, media.DataStream.Length); Assert.AreEqual(initialSize2, media.Size); Assert.AreEqual(true, media.IsAvailable); // Subsequent Updates should change nothing media.Update(); media.Update(); Assert.AreEqual(initialSize2, media.Size); Assert.AreEqual(initialSize2, media.DataStream.Length); Assert.AreEqual(true, media.IsAvailable); } rep.VerifyAll(); }
public void Format() { MockRepository mocks = new MockRepository(); IFilesStorageProviderV30 prov = mocks.StrictMock <IFilesStorageProviderV30>(); string content = string.Format( @"This is a test page. <countDownloads pattern=""#CoUnT#-#DaIlY#-#WeEkLy#-#MoNtHlY#"" startDate=""{0:yyyy'/'MM'/'dd}""> <file name=""/my/file.zip"" provider=""{1}"" /> <file name=""/my/other/file.zip"" /> <file name=""/my/inexistent-file.zip"" provider=""{1}"" /> <file name=""/my/other/inexistent-file.zip"" /> <attachment name=""attn.zip"" page=""page"" provider=""{1}"" /> <attachment name=""attn.zip"" page=""page"" /> <attachment name=""inexistent-attn.zip"" page=""page"" provider=""{1}"" /> <attachment name=""inexistent-attn.zip"" page=""page"" /> <attachment name=""attn.zip"" page=""inexistent-page"" provider=""{1}"" /> <attachment name=""attn.zip"" page=""inexistent-page"" /> </countDownloads>", DateTime.Today.AddDays(-60), prov.GetType().FullName); // */file.zip was downloaded 13 times // attn.zip was downloaded 56 times // Expected output: 138-2-16-68 IHostV30 host = mocks.StrictMock <IHostV30>(); host.LogEntry(null, LogEntryType.Warning, null, null); LastCall.On(host).IgnoreArguments().Repeat.Any(); Expect.Call(host.GetSettingValue(SettingName.DefaultFilesStorageProvider)).Return( prov.GetType().FullName).Repeat.Times(4); Expect.Call(host.GetFilesStorageProviders(true)).Return( new IFilesStorageProviderV30[] { prov }).Repeat.Times(8); StFileInfo[] myFiles = new StFileInfo[] { new StFileInfo(1000, DateTime.Now, 13, "/my/File.zip", prov), new StFileInfo(10000, DateTime.Now, 1000, "/my/other-file.zip", prov) }; StFileInfo[] myOtherFiles = new StFileInfo[] { new StFileInfo(1000, DateTime.Now, 13, "/my/OTHER/file.zip", prov), new StFileInfo(10000, DateTime.Now, 2000, "/my/OTHER/other-file.zip", prov) }; StFileInfo[] attachments = new StFileInfo[] { new StFileInfo(2000, DateTime.Now, 56, "aTTn.zip", prov), new StFileInfo(20000, DateTime.Now, 1000, "other-attn.zip", prov) }; // /my/* Expect.Call(host.ListFiles(null)).IgnoreArguments().Constraints( RMC.Is.Matching( delegate(StDirectoryInfo dir) { return(dir.FullPath == "/my/"); })).Return(myFiles).Repeat.Times(2); // /my/other/* Expect.Call(host.ListFiles(null)).IgnoreArguments().Constraints( RMC.Is.Matching( delegate(StDirectoryInfo dir) { return(dir.FullPath == "/my/other/"); })).Return(myOtherFiles).Repeat.Times(2); PageInfo page = new PageInfo("page", null, DateTime.Now); Expect.Call(host.FindPage("page")).Return(page).Repeat.Times(4); Expect.Call(host.FindPage("inexistent-page")).Return(null).Repeat.Twice(); Expect.Call(host.ListPageAttachments(page)).Return(attachments).Repeat.Times(4); mocks.ReplayAll(); DownloadCounter counter = new DownloadCounter(); counter.Init(host, ""); string output = counter.Format(content, null, FormattingPhase.Phase3); Assert.IsTrue(output == @"This is a test page. 138-2-16-68" || output == @"This is a test page. 138-2-16-69", "Wrong output"); mocks.VerifyAll(); }