public XShellModule(MainWindow window)
{
_container = new Container();
var persistenceService = new PersistenceService();
var menuManager = new DefaultMenuManager(window.MainMenu);
var screenManager = new WindowAvalonDockScreenManager(
window, window.MainPane,
(p1, p2) => _container.Register(p1, p2, setup: Setup.With(allowDisposableTransient: true)),
_container.Resolve, menuManager, persistenceService);
_container.RegisterInstance <IPersistenceService>(persistenceService);
_container.RegisterInstance <IMenuManager>(menuManager);
_container.RegisterInstance <IScreenContainer>(screenManager);
_container.RegisterInstance <IScreenManager>(screenManager);
_container.Register <IViewBox, ViewBox>();
_container.Register <IUiDispatcher, UiDispatcher>(Reuse.Singleton);
_container.Register <IBackgroundTaskManager, BackgroundTaskManager>(Reuse.Singleton);
_container.RegisterInstance(new StatusBarManager(window.BackgroundWorkerView, _container.Resolve <IBackgroundTaskManager>()));
RegisterServices(_container);
RegisterScreens(screenManager);
window.Closed += OnClosed;
}
public void SetUp()
{
_writeRepositoryMock = new Mock <IWriteRepository <Student> >();
_azureQueueSenderMock = new Mock <IAzureQueueSender <Student> >();
_service = new PersistenceService <Student>(_writeRepositoryMock.Object, _azureQueueSenderMock.Object);
_student = CreateStudent();
}
public async Task TestBigFile()
{
// arrange
TestHelper helper = new TestHelper();
PersistenceDB persistSQL = helper.GetAndInitLocalSqlServer();
PersistenceService ps = new PersistenceService(x => { return(x); }, persistSQL, null);
int count = 0;
bool complete = false;
string tempFile = string.Empty;
IDisposable subscription = Disposable.Empty;
// act
try
{
subscription = ps.TransactionElementsSource.Subscribe(x => count += x.Elements.Count, () => complete = true);
tempFile = helper.CreateTemporaryFileWithContent(helper.GetXMLFileAsString(helper.BFFTEST));
await ps.Start(tempFile);
// verify
Assert.IsTrue(complete);
Assert.AreEqual(113699, count);
}
finally
{
TestHelper.CleanupAfterTest(ps, tempFile, subscription);
}
}
// When the user clicks on a customer in their customer queue, the
// CustomerQueueController calls us to tell us to start working with
// the customer.
//
// Editing a customer is self-contained in a work item (the CustomerWorkItem)
// so we end up with one CustomerWorkItem contained in ourselves for
// each customer that is being edited.
public void WorkWithCustomer(Customer customer)
{
// Construct a key to register the work item in ourselves
string key = string.Format("Customer#{0}", customer.ID);
// Have we already made the work item for this customer?
// If so, return the existing one.
CustomerWorkItem workItem = this.Items.Get <CustomerWorkItem>(key);
if (workItem == null)
{
workItem = WorkItems.AddNew <CustomerWorkItem>(key);
//Set ID before setting state. State will be cleared if a new id is set.
workItem.ID = key;
workItem.State[StateConstants.CUSTOMER] = customer;
// Ask the persistence service if we have a saved version of
// this work item. If so, load it from persistence.
if (PersistenceService != null && PersistenceService.Contains(workItem.ID))
{
workItem.Load();
}
}
workItem.Show(contentWorkspace);
}
private void Navigate()
{
App.Master.IsPresented = false;
switch (this.PageName)
{
case "RutasPage":
MainViewModel.GetInstace().Rutas = new RutasViewModel();
App.Navigator.PushAsync(new RutasPage());
break;
case "ChoferesPage":
MainViewModel.GetInstace().Choferes = new ChoferesViewModel();
App.Navigator.PushAsync(new ChoferesPage());
break;
case "LoginPage":
//persistenceService = new PersistenceService();
PersistenceService.GetPersistenceService().RestoreKeysPersistance("usuario", "horaLogin", "guid");
//persistenceService.RestoreKeysPersistance("usuario", "horaLogin");
Application.Current.MainPage = new LoginPage();
break;
default:
break;
}
}
private async Task HandleDeleteFromIndexedDb()
{
BusyOverlayService.SetBusyState(BusyEnum.Busy);
var stopwatch = new Stopwatch();
stopwatch.Start();
ItemCount = Articles.Count;
foreach (var article in Articles)
{
await PersistenceService.DeleteAsync <Article>(article);
if (!UiUpdates)
{
continue;
}
ItemCount = Math.Max(0, ItemCount--);
ProcessingTimeMs = stopwatch.ElapsedMilliseconds;
if ((ItemCount % 100) == 0 || ItemCount == Articles.Count)
{
StateHasChanged();
await Task.Delay(1);
}
}
stopwatch.Stop();
ProcessingTimeMs = stopwatch.ElapsedMilliseconds;
BusyOverlayService.SetBusyState(BusyEnum.NotBusy);
}
public async Task StatsAsync(string commandName, string statsName)
{
SetMemberConfig(Context.User.Id);
if (PersistenceService.AvailableStats.Contains(commandName))
{
await StatsAsync(commandName);
return;
}
if (commandName.Trim().ToLower() != "reset")
{
await HandleErrorAsync(StatError.NoSuchCommand);
return;
}
if (!PersistenceService.AvailableStats.Contains(statsName))
{
await HandleErrorAsync(StatError.NoSuchCommand);
return;
}
PersistenceService.ClearUserRecord(statsName, Context.User.Id);
await Context.Channel.SendMessageAsync(_userLocalization["clear_message"].ToString());
}
private void OnGUI()
{
try {
_persistenceService = ServiceLocator.Get <PersistenceService>();
_songService = ServiceLocator.Get <SongService>();
_beatInputService = ServiceLocator.Get <BeatInputService>();
} catch (Exception) {
GUILayout.Label("Enter play mode to enable this window.");
return;
}
_persistenceToolsEnabled = EditorGUILayout.Foldout(_persistenceToolsEnabled, "Persistence", true);
if (_persistenceToolsEnabled)
{
DrawPersistence();
}
_beatInputToolsEnabled = EditorGUILayout.Foldout(_beatInputToolsEnabled, "Beat", true);
if (_beatInputToolsEnabled)
{
DrawBeatInput();
}
_levelToolsEnabled = EditorGUILayout.Foldout(_levelToolsEnabled, "Level", true);
if (_levelToolsEnabled)
{
DrawLevel();
}
}
private void StartApplication(StartupEventArgs e)
{
SetupAutomapper();
// TODO: Add IOC Container / Service locator
var userRequestsHelper = new UserRequestsHelper();
var persistenceService = new PersistenceService(AppDataFolder);
var torrentSessionService = new TorrentSessionService(DownloadsFolder);
var torrentsSessionViewModel = new TransferListViewModel(userRequestsHelper, persistenceService, torrentSessionService);
var mainWindowViewModel = new MainWindowViewModel(torrentsSessionViewModel);
var window = new MainWindow(mainWindowViewModel);
window.Show();
_notifyIconIconHelper = new SytemTrayIconHelper(window);
// TODO: Add a message broker
Current.Exit += (sender, args) =>
{
torrentsSessionViewModel.OnAplicationExit();
torrentSessionService.OnApplicationExit();
};
if (e.Args.Any())
{
torrentsSessionViewModel.AddNewTorrent(e.Args[0]);
}
_singleHelper.StartNewProcessListener(torrentsSessionViewModel, window);
}
public ITerminologyProvider CreateTerminologyProvider(Uri terminologyProviderUri,
ITerminologyProviderCredentialStore credentials)
{
TerminologyProviderExcel terminologyProvider = null;
try
{
var persistenceService = new PersistenceService();
var providerSettings = persistenceService.Load(terminologyProviderUri);
//in case we didn't any settings stored there is no need to load the provider
if (providerSettings == null)
{
// new Dictionary<string, string> { { "Uri", terminologyProviderUri.ToString() } });
return(terminologyProvider);
}
var termSearchService = new NormalTermSeachService(providerSettings);
terminologyProvider = new TerminologyProviderExcel(providerSettings, termSearchService);
Task.Run(terminologyProvider.LoadEntries);
}
catch (Exception ex)
{
throw ex;
}
return(terminologyProvider);
}
public PedidosViewModel(string bandera, RutaViewModel rutaVM)
{
this.apiService = new ApiService();
this.persistenceService = new PersistenceService();
rvm = rutaVM;
this.LoadPedidosForRuta();
}
public async Task <IActionResult> CompanyFinancialsRequest(Guid id, string exchangeId)
{
Authentication authentication = new Authentication(_ingestionContext, _logger);
TokenEntity tokenEntity = await authentication.GetAccessTokenByClientConfigId(id);
if (tokenEntity != null)
{
string endPoint = _configuration.GetValue <string>("MorningStar:EquityApi:CompanyFinancialAvailabilityList");
EquityApi.CompanyFinancials.Request request =
EquityApi.CompanyFinancials.Request.Create(tokenEntity.Token, exchangeId, "exchangeId", exchangeId);
string requestUrl = endPoint.SetQueryParams(request);
IngestionTask ingestionTask = IngestionTask.Create(endPoint, JsonConvert.SerializeObject(request));
_ingestionContext.IngestionTasks.Add(ingestionTask);
EquityApi.CompanyFinancials.Response response = await RestClient.GetDynamicResponseAsync <EquityApi.CompanyFinancials.Response>(requestUrl);
PersistenceService persistence = new PersistenceService(_ingestionContext, _mapper, _logger);
int result = await persistence.SaveAsync(ingestionTask.IngestionTaskId, response);
if (result > 0)
{
List <ChangeTable> changes = _ingestionContext.ChangeTables.FromSqlRaw("EXECUTE MergeCompanyFinancials @TaskId={0}", ingestionTask.IngestionTaskId).ToList();
_logger.LogInformation("MergeCompanyFinancials: {0}", JsonConvert.SerializeObject(changes));
}
return(Ok(result));
}
return(NotFound(id));
}
public async Task TestMedTestFileWriteFromTransaction()
{
// arrange
TestHelper helper = new TestHelper();
PersistenceService ps = helper.GetTestPersistenceService();
int count = 0;
bool complete = false;
string tempFile = string.Empty;
IDisposable subscription = Disposable.Empty;
// act
try
{
subscription = ps.TransactionElementsSource.Subscribe(x => count += x.Elements.Count, () => complete = true);
tempFile = helper.CreateTemporaryFileWithContent(helper.GetXMLFileAsString(helper.MEDIUMTESTFILE));
await ps.StartFromTransaction(tempFile, 32);
// verify
Assert.IsTrue(complete);
Assert.AreEqual(24, count);
}
finally
{
TestHelper.CleanupAfterTest(ps, tempFile, subscription);
}
}
protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
if (containerRegistry.GetContainer() is UnityContainer)
{
_container = containerRegistry.GetContainer() as UnityContainer;
}
containerRegistry.RegisterInstance <IWorkflow>(new Workflow());
_container?.RegisterType <IDialogService, DialogService>();
_container?.RegisterInstance <ILoader>(new Loader("Please Wait"));
string settingsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
IPersistenceService persistanceService = new PersistenceService(settingsDirectory);
_container.RegisterInstance(persistanceService);
// Headers.
containerRegistry.RegisterForNavigation <Header>(Pages.HomeHeader);
// Pages.
containerRegistry.RegisterForNavigation <DashboardPage>(Pages.Dashboard);
containerRegistry.RegisterForNavigation <CreateSectionPage>(Pages.CreateSection);
containerRegistry.RegisterForNavigation <ViewSectionPage>(Pages.ViewSection);
containerRegistry.RegisterForNavigation <EditSectionPage>(Pages.EditSection);
containerRegistry.RegisterForNavigation <AddApplicationPage>(Pages.AddApplication);
containerRegistry.RegisterForNavigation <EditApplicationPage>(Pages.EditApplication);
containerRegistry.RegisterForNavigation <LoadingPage>(Pages.Loading);
containerRegistry.RegisterForNavigation <AddNotePage>(Pages.AddNote);
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var container = new Container();
var mainForm = new MainForm();
var persistenceService = new PersistenceService();
var menuManager = new ToolStripMenuManager(mainForm.MainMenuStrip);
var screenManager = new FormDockPanelScreenManager(mainForm, mainForm.MainDockPanel,
(p1, p2) => container.Register(p1, p2, setup: Setup.With(allowDisposableTransient: true)), container.Resolve,
menuManager, persistenceService);
container.RegisterInstance <IPersistenceService>(persistenceService);
container.RegisterInstance <IMenuManager>(menuManager);
container.RegisterInstance <IScreenContainer>(screenManager);
container.RegisterInstance <IScreenManager>(screenManager);
container.RegisterInstance <IUiDispatcher>(new UiDispatcher(mainForm));
container.Register <IBackgroundTaskManager, BackgroundTaskManager>(Reuse.Singleton);
container.RegisterInstance(new StatusBarManager(mainForm.StatusProgressBar, mainForm.StatusProgressLabel, container.Resolve <IBackgroundTaskManager>()));
RegisterServices(container);
RegisterScreens(screenManager);
Application.Run(mainForm);
container.Dispose();
}
public void ShouldComplainIfNoUpdatePersistenceServiceFound()
{
{
var persistenceService = new PersistenceService();
Should.Throw <PersistenceMethodNotFoundException>(() => { persistenceService.Update(new MyClass()); });
}
}
public ITerminologyProvider CreateTerminologyProvider(Uri terminologyProviderUri,
ITerminologyProviderCredentialStore credentials)
{
TerminologyProviderExcel terminologyProvider;
try
{
var persistenceService = new PersistenceService();
var providerSettings = persistenceService.Load(terminologyProviderUri);
//in case we didn't any settings stored there is no need to load the provider
if (providerSettings == null)
{
return(null);
}
var termSearchService = new NormalTermSeachService(providerSettings);
terminologyProvider = new TerminologyProviderExcel(providerSettings, termSearchService);
Task.Run(terminologyProvider.LoadEntries);
}
catch (Exception ex)
{
Log.Logger.Error($"CreateTerminologyProvider method: {ex.Message}\n {ex.StackTrace}");
throw ex;
}
return(terminologyProvider);
}
public ITranslationProvider CreateTranslationProvider(Uri translationProviderUri, string translationProviderState, ITranslationProviderCredentialStore credentialStore)
{
DtSearch4StudioProvider dtSearch4StudioProvider;
try
{
var persistenceService = new PersistenceService();
var providerSettings = persistenceService.GetProviderSettings();
// in case we didn't have any settings stored there is no need to load the provider
if (providerSettings == null)
{
MessageBox.Show(Constants.EmptyProvider, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(null);
}
//var searchService = new SearchService();
dtSearch4StudioProvider = new DtSearch4StudioProvider(providerSettings);
}
catch (Exception ex)
{
Log.Logger.Error($"{Constants.CreateTranslationProvider}: {ex.Message}\n {ex.StackTrace}");
throw ex;
}
return(dtSearch4StudioProvider);
}
public ITerminologyProvider[] Browse(IWin32Window owner, ITerminologyProviderCredentialStore credentialStore)
{
var result = new List <ITerminologyProvider>();
try
{
var settingsDialog = new Settings();
var dialogResult = settingsDialog.ShowDialog();
if (dialogResult == DialogResult.OK ||
dialogResult == DialogResult.Yes)
{
var settings = settingsDialog.GetSettings();
var persistenceService = new PersistenceService();
var provider = new TerminologyProviderExcel(settings);
settings.Uri = provider.Uri;
persistenceService.AddSettings(settings);
var providerSettings = persistenceService.Load(provider.Uri);
var termSearchService = new NormalTermSeachService(providerSettings);
var excelProvider = new TerminologyProviderExcel(providerSettings, termSearchService);
result.Add(excelProvider);
}
}
catch (Exception ex)
{
throw ex;
}
return(result.ToArray());
}
public void GetNumbersOfGuestsSuccess()
{
ObservableCollection <Guest> testCollection = new ObservableCollection <Guest>();
testCollection = PersistenceService.GetGuestsAsync().Result;
//Forventer en Success, da der er 34 gæster på listen pt.
Assert.AreEqual(34, testCollection.Count);
}
// Delete/REMOVE en Guest
public void RemoveGuest(/*int Guest_No,*/ Guest deleteGuest)
{
if (deleteGuest != null)
{
GuestsCollection.Remove(deleteGuest);
PersistenceService.DeleteAsyncGuest(/*Guest_No,*/ deleteGuest);
}
}
public void ShouldComplainIfNoCreatePersistenceServiceFound()
{
{
var persistenceService = new PersistenceService();
Assert.Throws <PersistenceMethodNotFoundException>(() => { persistenceService.Create(new MyClass()); });
}
}
CanCreateNewGameDB()
{
var service = new PersistenceService("SQLEXPRESS");
const long gameID = 60;
service.CreateGameDB(gameID);
service.DeleteGameDB(gameID);
}
public void ShouldComplainIfNoCreatePersistenceServiceFoundForList()
{
{
var persistenceService = new PersistenceService();
Should.Throw <PersistenceMethodNotFoundException>(
() => { persistenceService.Create((IList <MyClass>) new List <MyClass>()); });
}
}
public UserViewModel(UserAccount user) : base(user)
{
this.person = user.getPerson();
var svc = new PersistenceService();
AvailableRoles = from role in svc.GetEntities <Employee>() select new RoleViewModel(role);
this.dateOfBirth = this.person.getDOB()?.ToShortDateString();
}
public bool Edit(IWin32Window owner, ITerminologyProvider terminologyProvider)
{
var persistenceService = new PersistenceService();
var providerSettings = persistenceService.Load();
SetTerminologyProvider(terminologyProvider as IATETerminologyProvider, providerSettings);
return(true);
}
public static void InitApp(String applicationId, String apiKey)
{
if (String.IsNullOrEmpty(applicationId))
{
throw new ArgumentNullException(ExceptionMessage.NULL_APPLICATION_ID);
}
if (String.IsNullOrEmpty(apiKey))
{
throw new ArgumentNullException(ExceptionMessage.NULL_SECRET_KEY);
}
Log.addLogger(Log.DEFAULTLOGGER, new ConsoleLogger());
Log.startLogging(BACKENDLESSLOG);
#if WITHRT
Quobject.EngineIoClientDotNet.Modules.LogManager.Enabled = !DeviceCheck.IsMobile;
#endif
AppId = applicationId;
APIKey = apiKey;
Persistence = new PersistenceService();
Data = Persistence;
Geo = new GeoService();
Messaging = new MessagingService();
Files = new FileService();
UserService = new UserService();
Events = Events.GetInstance();
Cache = Cache.GetInstance();
Counters = CounterService.GetInstance();
Logging = new LoggingService();
CustomService = new CustomService();
#if WITHRT
RT = new RTServiceImpl();
#endif
MessageWriter.DefaultWriter = new UnderflowWriter();
MessageWriter.AddAdditionalTypeWriter(typeof(BackendlessUser), new BackendlessUserWriter());
MessageWriter.AddAdditionalTypeWriter(typeof(Geometry), new BackendlessGeometryWriter());
MessageWriter.AddAdditionalTypeWriter(typeof(Point), new BackendlessGeometryWriter());
MessageWriter.AddAdditionalTypeWriter(typeof(LineString), new BackendlessGeometryWriter());
MessageWriter.AddAdditionalTypeWriter(typeof(Polygon), new BackendlessGeometryWriter());
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory(typeof(BackendlessUser).FullName, new BackendlessUserFactory());
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory(typeof(GeometryDTO).FullName, new BackendlessGeometryFactory());
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory(typeof(Geometry).FullName, new BackendlessGeometryFactory());
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory(typeof(Point).FullName, new BackendlessGeometryFactory());
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory(typeof(LineString).FullName, new BackendlessGeometryFactory());
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory(typeof(Polygon).FullName, new BackendlessGeometryFactory());
HeadersManager.CleanHeaders();
LoginStorage loginStorage = new LoginStorage();
if (loginStorage.HasData)
{
HeadersManager.GetInstance().AddHeader(HeadersEnum.USER_TOKEN_KEY, loginStorage.UserToken);
}
}
public ITerminologyProvider CreateTerminologyProvider(Uri terminologyProviderUri, ITerminologyProviderCredentialStore credentials)
{
var persistenceService = new PersistenceService();
var providerSettings = persistenceService.Load();
var terminologyProvider = new IATETerminologyProvider(providerSettings);
return(terminologyProvider);
}
public void Start()
{
persistenceService = GetComponent <PersistenceService>();
playerService = GetComponent <PlayerService>();
controllers = new Dictionary <int, HumanInputController>();
EventManager.TriggerEvent <Events.ServiceReady, Type>(typeof(InputService));
}
public PersistenceHostedService(ILogger <PersistenceHostedService> logger
, PersistenceService persistenceService
, WorldState worldState
)
{
this.logger = logger;
this.persistenceService = persistenceService;
this.worldState = worldState;
}
public void ShouldBeAbleToPersistAnObject_Update()
{
var obj = new MyClass();
PersistenceService persistenceService = new PersistenceService();
persistenceService.SetPersistenceUpdateMethod<MyClass>(x => repository.Save(x));
using (mocks.Record())
{
repository.Expect(x => x.Save(obj));
}
using (mocks.Playback())
{
persistenceService.Update(obj);
}
}
public void ShouldBeAbleToPersistAList_Create()
{
IList<MyClass> list = new List<MyClass>();
PersistenceService persistenceService = new PersistenceService();
persistenceService.SetPersistenceCreateMethod<IList<MyClass>>(x => repository.SaveAll(x));
using (mocks.Record())
{
repository.Expect(x => x.SaveAll(list));
}
using (mocks.Playback())
{
persistenceService.Create(list);
}
}
public static void InitApp( string applicationId, string secretKey, string version )
{
if( string.IsNullOrEmpty( applicationId ) )
throw new ArgumentNullException( ExceptionMessage.NULL_APPLICATION_ID );
if( string.IsNullOrEmpty( secretKey ) )
throw new ArgumentNullException(ExceptionMessage.NULL_SECRET_KEY);
if( string.IsNullOrEmpty( version ) )
throw new ArgumentNullException(ExceptionMessage.NULL_VERSION);
AppId = applicationId;
SecretKey = secretKey;
VersionNum = version;
Persistence = new PersistenceService();
Data = Persistence;
Geo = new GeoService();
Messaging = new MessagingService();
Files = new FileService();
UserService = new UserService();
Events = Events.GetInstance();
Cache = Cache.GetInstance();
Counters = CounterService.GetInstance();
Logging = new LoggingService();
CustomService = new CustomService();
MessageWriter.DefaultWriter = new UnderflowWriter();
MessageWriter.AddAdditionalTypeWriter( typeof( BackendlessUser ), new BackendlessUserWriter() );
ORBConfig.GetInstance().getObjectFactories().AddArgumentObjectFactory( typeof( BackendlessUser ).FullName, new BackendlessUserFactory() );
HeadersManager.CleanHeaders();
LoginStorage loginStorage = new LoginStorage();
if( loginStorage.HasData )
HeadersManager.GetInstance().AddHeader( HeadersEnum.USER_TOKEN_KEY, loginStorage.UserToken );
}
public void SetUp()
{
_fakeKvStorage = new FakeKVStorage();
_persistenceService = new PersistenceService(_fakeKvStorage);
}
public void ShouldComplainIfNoUpdatePersistenceServiceFoundForList()
{
using (mocks.Record()) { }
using (mocks.Playback())
{
PersistenceService persistenceService = new PersistenceService();
persistenceService.Update((IList<MyClass>)new List<MyClass>());
}
}
public void ShouldComplainIfNoUpdatePersistenceServiceFound()
{
using (mocks.Record()) { }
using (mocks.Playback())
{
PersistenceService persistenceService = new PersistenceService();
persistenceService.Update(new MyClass());
}
}
public void ShouldReplaceExistingUpdatePersister()
{
var obj = new MyClass();
PersistenceService persistenceService = new PersistenceService();
persistenceService.SetPersistenceUpdateMethod<MyClass>(x => repository.Save(x));
persistenceService.SetPersistenceUpdateMethod<MyClass>(x => repository2.Save(x));
using (mocks.Record())
{
repository2.Expect(x => x.Save(obj));
}
using (mocks.Playback())
{
persistenceService.Update(obj);
}
}
public void ShouldComplainIfNoCreatePersistenceServiceFound()
{
using (mocks.Record()) { }
using (mocks.Playback())
{
PersistenceService persistenceService = new PersistenceService();
Assert.Throws<PersistenceMethodNotFoundException>(() =>
{
persistenceService.Create(new MyClass());
});
}
}
public void ShouldComplainIfNoUpdatePersistenceServiceFoundForList()
{
using (mocks.Record()) { }
using (mocks.Playback())
{
PersistenceService persistenceService = new PersistenceService();
Assert.Throws<PersistenceMethodNotFoundException>(() =>
{
persistenceService.Update((IList<MyClass>)new List<MyClass>());
});
}
}
