public async Task Test_ResetDownloads_Multiple()
{
Console.WriteLine("Test_ResetDownloads_Multiple");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var waiting = new Download {
State = State.Waiting
};
var error = new Download {
State = State.Error
};
var downloading = new Download {
State = State.Downloading
};
var finished = new Download {
State = State.Finished
};
repo.Insert(waiting);
repo.Insert(downloading);
repo.Insert(error);
repo.Insert(finished);
manager.ResetDownloads(new ResetDownloads {
});
var all = repo.All();
Assert.AreEqual(0, all.Count);
}
public async Task Test_FinishDownload_Finish1()
{
Console.WriteLine("Test_FinishDownload_Finish1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
};
repo.Insert(download);
manager.FinishedDownload(new FinishedDownload {
Id = download.Id,
});
Assert.AreEqual(ErrorEnum.Empty, downloaderror, "Downloaderror");
Assert.AreEqual(State.Finished, download.State, "Finished");
}
public async Task Test_DownloadError_Error1()
{
Console.WriteLine("Test_DownloadError_Error1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadError(new DownloadError {
Id = 0,
Error = ErrorEnum.Empty,
});
wait1.WaitOne(10);
Assert.AreEqual(ErrorEnum.Empty, error);
}
public async Task Test_CancelDownloads_Multiple ()
{
Console.WriteLine ("Test_CancelDownloads_Multiple");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting = new Download { State = State.Waiting };
var error = new Download { State = State.Error };
var downloading = new Download { State = State.Downloading };
var finished = new Download { State = State.Finished };
repo.Insert (waiting);
repo.Insert (downloading);
repo.Insert (error);
repo.Insert (finished);
manager.CancelDownloads (new CancelDownloads {
});
Assert.AreEqual (State.Finished, waiting.State, "Waiting");
Assert.AreEqual (State.Finished, downloading.State, "Downloading");
Assert.AreEqual (State.Finished, error.State, "Error");
Assert.AreEqual (State.Finished, finished.State, "Finished");
}
public async Task Test_DownloadRejected_Error1()
{
Console.WriteLine("Test_DownloadRejected_Error1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadRejected(new DownloadRejected {
Id = 0,
Reason = RejectionEnum.QueueFull
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.DownloadRejected_IdentifierNotFound, error);
}
public async Task Test_DownloadError_Error2 ()
{
Console.WriteLine ("Test_DownloadError_Error2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadError (new DownloadError {
Id = 0,
Error = ErrorEnum.DidCompleteWithError_Error,
});
wait1.WaitOne (10);
Assert.AreEqual (ErrorEnum.Empty, error);
}
public async Task Test_FreeSlot_Queued_Error()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
var wait1 = new AutoResetEvent(false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe <QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe <QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip",
State = State.Error
});
manager.FreeSlot(new FreeSlot {
});
wait1.WaitOne();
Assert.AreEqual(false, queueDownload);
Assert.AreEqual(true, queueEmpty);
}
public async Task Test_DownloadRejected_1 ()
{
Console.WriteLine ("Test_DownloadRejected_1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Downloading };
repo.Insert (download);
manager.DownloadRejected (new DownloadRejected {
Id = 1,
Reason = RejectionEnum.QueueFull
});
Assert.AreEqual (State.Waiting, download.State);
}
public async Task Test_ResetDownloads_Multiple2 ()
{
Console.WriteLine ("Test_ResetDownloads_Multiple2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting1 = new Download { State = State.Waiting };
var waiting2 = new Download { State = State.Waiting };
var waiting3 = new Download { State = State.Waiting };
var waiting4 = new Download { State = State.Waiting };
var waiting5 = new Download { State = State.Waiting };
repo.Insert (waiting1);
repo.Insert (waiting2);
repo.Insert (waiting3);
repo.Insert (waiting4);
repo.Insert (waiting5);
manager.ResetDownloads (new ResetDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public Downloader()
{
var personal = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
var dbpath = Path.Combine(personal, "download.db");
var db = new SQLiteConnection(
dbpath,
SQLiteOpenFlags.ReadWrite
| SQLiteOpenFlags.Create
| SQLiteOpenFlags.FullMutex,
true)
{
#if DEBUG
Trace = true
#endif
};
int maxdownloads = 3;
_bus = new InProcessBus();
_repository = new DownloadRepository(db);
_manager = new DownloadManager(_bus, _repository, maxdownloads);
_service = new NSUrlSessionManager(_bus, maxdownloads);
_progress = new ProgressManager(_bus, _repository);
_timer = new Timer(TimerCallback, null, 1000, 1000);
_timer = new Timer(TimerCallback, null, 1000, 1000);
_bus.Subscribe <DownloadError> (DownloadError_Received);
_bus.Subscribe <TaskError> (TaskError_Received);
_bus.Subscribe <QueueEmpty> (QueueEmpty_Received);
_bus.Subscribe <GlobalProgress> (GlobalProgress_Received);
_bus.Subscribe <NotifyFinish> (NotifyFinish_Received);
}
public async Task Test_ProgressDownload_Progress1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
Total = 0,
Written = 0
};
repo.Insert(download);
manager.ProgressDownload(new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
Assert.AreEqual(10, download.Written, "Written");
Assert.AreEqual(1000, download.Total, "Total");
Assert.AreEqual(ErrorEnum.Empty, downloaderror, "Downloaderror");
}
public async Task Test_ProgressDownload_ErrorInvalidState1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
var wait1 = new AutoResetEvent(false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Finished,
Total = 0,
Written = 0
};
repo.Insert(download);
manager.ProgressDownload(new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
wait1.WaitOne();
Assert.AreEqual(0, download.Written, "Written");
Assert.AreEqual(0, download.Total, "Total");
Assert.AreEqual(ErrorEnum.ProgressDownload_InvalidState, downloaderror, "DownloadError");
}
public async Task Test_FreeSlot_Nowait1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo);
var wait1 = new AutoResetEvent(false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe <QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe <QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
manager.FreeSlot(new FreeSlot {
});
wait1.WaitOne();
Assert.AreEqual(false, queueDownload);
Assert.AreEqual(true, queueEmpty);
}
public async Task Test_DownloadError_Error500()
{
Console.WriteLine("Test_DownloadError_Error500");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download {
Url = "url", State = State.Downloading
};
repo.Insert(download);
manager.TaskError(new TaskError {
Id = download.Id,
Error = TaskErrorEnum.InvalidResponse,
StatusCode = 500
});
Assert.AreEqual(State.Error, download.State);
Assert.AreEqual(500, download.StatusCode);
}
public Downloader ()
{
var personal = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
var dbpath = Path.Combine (personal, "download.db");
var db = new SQLiteConnection (
dbpath,
SQLiteOpenFlags.ReadWrite
| SQLiteOpenFlags.Create
| SQLiteOpenFlags.FullMutex ,
true) {
#if DEBUG
Trace = true
#endif
};
int maxdownloads = 3;
_bus = new InProcessBus ();
_repository = new DownloadRepository (db);
_manager = new DownloadManager (_bus, _repository, maxdownloads);
_service = new NSUrlSessionManager (_bus, maxdownloads);
_progress = new ProgressManager (_bus, _repository);
_timer = new Timer (TimerCallback, null, 1000, 1000);
_timer = new Timer (TimerCallback, null, 1000, 1000);
_bus.Subscribe<DownloadError> (DownloadError_Received);
_bus.Subscribe<TaskError> (TaskError_Received);
_bus.Subscribe<QueueEmpty> (QueueEmpty_Received);
_bus.Subscribe<GlobalProgress> (GlobalProgress_Received);
_bus.Subscribe<NotifyFinish> (NotifyFinish_Received);
}
public async Task Test_DownloadRejected_Error1 ()
{
Console.WriteLine ("Test_DownloadRejected_Error1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.DownloadRejected (new DownloadRejected {
Id = 0,
Reason = RejectionEnum.QueueFull
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.DownloadRejected_IdentifierNotFound, error);
}
public async Task Test_FinishDownload_Finish1 ()
{
Console.WriteLine ("Test_FinishDownload_Finish1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
};
repo.Insert (download);
manager.FinishedDownload (new FinishedDownload {
Id = download.Id,
});
Assert.AreEqual (ErrorEnum.Empty, downloaderror, "Downloaderror");
Assert.AreEqual (State.Finished, download.State, "Finished");
}
public static IServiceCollection AddPlatformServices(this IServiceCollection services, IConfiguration configuration)
{
services.AddDbContext <PlatformDbContext>(options => options.UseSqlServer(configuration.GetConnectionString("VirtoCommerce")));
services.AddTransient <IPlatformRepository, PlatformRepository>();
services.AddSingleton <Func <IPlatformRepository> >(provider => () => provider.CreateScope().ServiceProvider.GetService <IPlatformRepository>());
services.AddSettings();
services.AddDynamicProperties();
services.AddSingleton <IPushNotificationManager, PushNotificationManager>();
var inProcessBus = new InProcessBus();
services.AddSingleton <IHandlerRegistrar>(inProcessBus);
services.AddSingleton <IEventPublisher>(inProcessBus);
services.AddSingleton <IChangeLogService, ChangeLogService>();
services.AddSingleton <IChangeLogSearchService, ChangeLogSearchService>();
//Use MemoryCache decorator to use global platform cache settings
services.AddSingleton <IPlatformMemoryCache, PlatformMemoryCache>();
services.AddScoped <IPlatformExportImportManager, PlatformExportImportManager>();
services.AddSingleton <ITransactionFileManager, TransactionFileManager.TransactionFileManager>();
services.AddTransient <IEmailSender, DefaultEmailSender>();
services.AddSingleton(js =>
{
var serv = js.GetService <IOptions <MvcJsonOptions> >();
return(JsonSerializer.Create(serv.Value.SerializerSettings));
});
return(services);
}
public async Task Test_ProgressDownload_DownloadError1()
{
Console.WriteLine("Test_ProgressDownload_DownloadError1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
manager.ProgressDownload(new ProgressDownload {
Id = 1,
Total = 1000,
Written = 10
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.ProgressDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public static IServiceCollection AddPlatformServices(this IServiceCollection services, IConfiguration configuration)
{
services.AddDbContext <PlatformDbContext>(options => options.UseSqlServer(configuration.GetConnectionString("VirtoCommerce")));
services.AddTransient <IPlatformRepository, PlatformRepository>();
services.AddTransient <Func <IPlatformRepository> >(provider => () => provider.CreateScope().ServiceProvider.GetService <IPlatformRepository>());
services.AddSettings();
services.AddDynamicProperties();
var inProcessBus = new InProcessBus();
services.AddSingleton <IHandlerRegistrar>(inProcessBus);
services.AddSingleton <IEventPublisher>(inProcessBus);
services.AddTransient <IChangeLogService, ChangeLogService>();
services.AddTransient <IChangeLogSearchService, ChangeLogSearchService>();
services.AddCaching(configuration);
services.AddScoped <IPlatformExportImportManager, PlatformExportImportManager>();
services.AddSingleton <ITransactionFileManager, TransactionFileManager.TransactionFileManager>();
services.AddTransient <IEmailSender, DefaultEmailSender>();
//Register dependencies for translation
services.AddSingleton <ITranslationDataProvider, PlatformTranslationDataProvider>();
services.AddSingleton <ITranslationDataProvider, ModulesTranslationDataProvider>();
services.AddSingleton <ITranslationService, TranslationService>();
services.AddSingleton <IFileSystem, FileSystem>();
services.AddTransient <IZipFileWrapper, ZipFileWrapper>();
return(services);
}
public async Task Test_FinishDownload_ErrorNotFound2()
{
Console.WriteLine("Test_FinishDownload_ErrorNotFound2");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Downloading,
};
repo.Insert(download);
manager.FinishedDownload(new FinishedDownload {
Id = 666,
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.FinishedDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_QueueUrl_AlreadyQueued1()
{
Console.WriteLine("Test_QueueUrl_AlreadyQueued1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe <AlreadyQueued> (p => {
alreadyQueued = true;
wait1.Set();
});
bus.Subscribe <CheckFreeSlot> (p => {
checkFreeSlot = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip"
});
manager.QueueUrl(new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait1.WaitOne();
Assert.AreEqual(false, checkFreeSlot);
Assert.AreEqual(true, alreadyQueued);
}
private void Run()
{
var bus = new InProcessBus();
// Delegate Handler
bus.Subscribe <string>(message => Console.WriteLine("Delegate Handler Received: {0}", message));
bus.Subscribe <string>(async(message, token) => await WriteMessageAsync(message, token));
// Strongly typed handler
bus.Subscribe <Message>(() => new MessageHandler());
// Strongly typed async handler
bus.Subscribe <Message>(() => new AsyncMessageHandler()); // will automatically be passed a cancellation token
Console.WriteLine("Enter a message\n");
string input;
while ((input = Console.ReadLine()) != "q")
{
var t2 = bus.SendAsync(input);
var t1 = bus.SendAsync(new Message {
Body = input
});
Task.WaitAll(t1, t2);
Console.WriteLine("\nEnter another message\n");
}
}
public async Task Test_DownloadError_Error3()
{
Console.WriteLine("Test_DownloadError_Error3");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download {
Url = "url", State = State.Finished
};
repo.Insert(download);
manager.DownloadError(new DownloadError {
Id = download.Id,
Error = ErrorEnum.DidCompleteWithError_Error,
});
wait1.WaitOne(10);
Assert.AreEqual(ErrorEnum.Empty, error);
}
public async Task Test_QueueUrl_AlreadyQueued1 ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe<AlreadyQueued> (p => {
alreadyQueued = true;
wait1.Set();
});
bus.Subscribe<CheckFreeSlot> (p => {
checkFreeSlot = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip"
});
manager.QueueUrl (new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait1.WaitOne ();
Assert.AreEqual (false, checkFreeSlot);
Assert.AreEqual (true, alreadyQueued);
}
public async Task Test_DownloadRejected_1()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download {
Url = "url", State = State.Downloading
};
repo.Insert(download);
manager.DownloadRejected(new DownloadRejected {
Id = 1,
Reason = RejectionEnum.QueueFull
});
Assert.AreEqual(State.Waiting, download.State);
}
private MockDependencyResolver()
{
ContextFactory = new ThreadedContextItemCollectionFactory();
CorrelationIdHelper = new CorrelationIdHelper((ThreadedContextItemCollectionFactory)ContextFactory);
ConfigurationManager = new ConfigurationManager();
Logger = new TraceLogger(new LoggerSettings(), CorrelationIdHelper);
EventStore = EventStoreCreator(this);
Bus = new InProcessBus <TAuthenticationToken>
(
(IAuthenticationTokenHelper <TAuthenticationToken>) new DefaultAuthenticationTokenHelper(ContextFactory),
CorrelationIdHelper,
this,
Logger,
ConfigurationManager,
new BusHelper(ConfigurationManager, ContextFactory)
);
AggregateRepository = new AggregateRepository <TAuthenticationToken>
(
new AggregateFactory(this, Logger),
EventStore,
Bus,
CorrelationIdHelper,
ConfigurationManager
);
}
public ServiceBusRegistry()
{
For <IReportingRepository <PatientDto> >()
.Use <SqlReportingRepository>()
.Ctor <string>()
.Is(AppConfig.PatientDBEventStoreEntities);
var bus = new InProcessBus();
For <IBus>().Use(bus);
var eventStore = GetInitializedEventStore(bus);
var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector());
For <IStoreEvents>()
.Use(eventStore);
For <IRepository>()
.Use(repository);
For <IHandles <CreatePatientCommand> >()
.Use <CreatePatientCommandHandler>();
For <IHandles <ChangePatientNameCommand> >()
.Use <ChangePatientNameCommandHandler>();
}
public async Task Test_DownloadRejected_Error2()
{
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe <DownloadError> (p => {
error = p.Error;
wait1.Set();
});
repo.Insert(new Download {
Url = "url", State = State.Finished
});
manager.DownloadRejected(new DownloadRejected {
Id = 1,
Reason = RejectionEnum.QueueFull
});
wait1.WaitOne();
Assert.AreEqual(ErrorEnum.DownloadRejected_InvalidState, error);
}
public async Task Test_ProgressDownload_Progress1 ()
{
Console.WriteLine ("Test_ProgressDownload_Progress1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
});
var download = new Download {
State = State.Downloading,
Total = 0,
Written = 0
};
repo.Insert (download);
manager.ProgressDownload (new ProgressDownload {
Id = download.Id,
Total = 1000,
Written = 10
});
Assert.AreEqual (10, download.Written, "Written");
Assert.AreEqual (1000, download.Total, "Total");
Assert.AreEqual (ErrorEnum.Empty, downloaderror, "Downloaderror");
}
public async Task Test_ProgressDownload_ErrorNotFound2 ()
{
Console.WriteLine ("Test_ProgressDownload_ErrorNotFound2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
var download = new Download {
State = State.Downloading,
Total = 0,
Written = 0
};
repo.Insert (download);
manager.ProgressDownload (new ProgressDownload {
Id = 666,
Total = 1000,
Written = 10
});
wait1.WaitOne ();
Assert.AreEqual (0, download.Written, "Written");
Assert.AreEqual (0, download.Total, "Total");
Assert.AreEqual (ErrorEnum.ProgressDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_DownloadError_Error3 ()
{
Console.WriteLine ("Test_DownloadError_Error3");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Finished };
repo.Insert (download);
manager.TaskError (new TaskError {
Id = download.Id,
Error = TaskErrorEnum.DownloadError,
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.TaskError_InvalidState, error);
}
public async Task Test_DownloadError_Error2 ()
{
Console.WriteLine ("Test_DownloadError_Error2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
manager.TaskError (new TaskError {
Id = 0,
Error = TaskErrorEnum.InvalidResponse,
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.TaskError_IdentifierNotFound, error);
}
public async Task Test_CancelDownloads_Multiple2 ()
{
Console.WriteLine ("Test_CancelDownloads_Multiple2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting1 = new Download { State = State.Waiting };
var waiting2 = new Download { State = State.Waiting };
var waiting3 = new Download { State = State.Waiting };
var waiting4 = new Download { State = State.Waiting };
var waiting5 = new Download { State = State.Waiting };
repo.Insert (waiting1);
repo.Insert (waiting2);
repo.Insert (waiting3);
repo.Insert (waiting4);
repo.Insert (waiting5);
manager.CancelDownloads (new CancelDownloads {
});
Assert.AreEqual (State.Finished, waiting1.State, "Waiting1");
Assert.AreEqual (State.Finished, waiting2.State, "Waiting2");
Assert.AreEqual (State.Finished, waiting3.State, "Waiting3");
Assert.AreEqual (State.Finished, waiting4.State, "Waiting4");
Assert.AreEqual (State.Finished, waiting5.State, "Waiting5");
}
public async Task Test_CancelDownloads_Multiple()
{
Console.WriteLine("Test_CancelDownloads_Multiple");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var waiting = new Download {
State = State.Waiting
};
var error = new Download {
State = State.Error
};
var downloading = new Download {
State = State.Downloading
};
var finished = new Download {
State = State.Finished
};
repo.Insert(waiting);
repo.Insert(downloading);
repo.Insert(error);
repo.Insert(finished);
manager.CancelDownloads(new CancelDownloads {
});
Assert.AreEqual(State.Finished, waiting.State, "Waiting");
Assert.AreEqual(State.Finished, downloading.State, "Downloading");
Assert.AreEqual(State.Finished, error.State, "Error");
Assert.AreEqual(State.Finished, finished.State, "Finished");
}
public void SubscriptionShouldNotBeNull()
{
InProcessBus sut = new InProcessBus();
IEventHandler <AccountCreatedEvent> fakeHandler = A.Fake <IEventHandler <AccountCreatedEvent> >();
IDisposable subscription = sut.Subscribe(fakeHandler);
subscription.Should().NotBeNull();
}
public void Queue_2()
{
Console.WriteLine("Queue_2");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
long total = 0;
long written = 0;
var wait1 = new AutoResetEvent(false);
var download = new Download {
Url = "url",
Total = 0,
Written = 0
};
repo.Insert(download);
var progressmanager = new ProgressManager(bus, repo);
Action <Download> progresshandle = (d) => {
total = d.Total;
written = d.Written;
wait1.Set();
};
progressmanager.Queue(download.Url, progresshandle);
download.Total = 100;
download.Written = 10;
progressmanager.NotifyProgress(new NotifyProgress {
Url = download.Url,
Download = download
});
download.Written = 50;
progressmanager.NotifyProgress(new NotifyProgress {
Url = download.Url,
Download = download
});
download.Written = 100;
progressmanager.NotifyProgress(new NotifyProgress {
Url = download.Url,
Download = download
});
wait1.WaitOne();
wait1.WaitOne();
wait1.WaitOne();
Assert.AreEqual(100, written, "Written");
Assert.AreEqual(100, total, "Total");
}
public void Queue_2 ()
{
Console.WriteLine ("Queue_2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
long total = 0;
long written = 0;
var wait1 = new AutoResetEvent (false);
var download = new Download {
Url = "url",
Total = 0,
Written = 0
};
repo.Insert (download);
var progressmanager = new ProgressManager (bus, repo);
Action<Download> progresshandle = (d) => {
total = d.Total;
written = d.Written;
wait1.Set();
};
progressmanager.Queue (download.Url, progresshandle);
download.Total = 100;
download.Written = 10;
progressmanager.NotifyProgress (new NotifyProgress {
Url = download.Url,
Download = download
});
download.Written = 50;
progressmanager.NotifyProgress (new NotifyProgress {
Url = download.Url,
Download = download
});
download.Written = 100;
progressmanager.NotifyProgress (new NotifyProgress {
Url = download.Url,
Download = download
});
wait1.WaitOne ();
wait1.WaitOne ();
wait1.WaitOne ();
Assert.AreEqual (100, written, "Written");
Assert.AreEqual (100, total, "Total");
}
public void SubscribedHandlerShouldHandle()
{
InProcessBus sut = new InProcessBus();
IEventHandler <AccountCreatedEvent> fakeHandler = A.Fake <IEventHandler <AccountCreatedEvent> >();
IDisposable subscription = sut.Subscribe(fakeHandler);
sut.Publish(new AccountCreatedEvent(Guid.NewGuid(), 0, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), false));
A.CallTo(() => fakeHandler.Handle(A <AccountCreatedEvent> .Ignored)).MustHaveHappened();
}
public static void ClassInitialise(TestContext context)
{
sut = new InProcessBus();
sut.Subscribe(A.Fake <ICommandHandler <PokeSimpleAggregate> >());
sut.Subscribe(A.Fake <ICommandHandler <PokeSimpleAggregate> >());
sut.Subscribe(A.Fake <IEventHandler <SimpleAggregateCreated> >());
createdHandler = A.Fake <IEventHandler <SimpleAggregateCreated> >();
sut.Subscribe(createdHandler);
peekHandler = A.Fake <ICommandHandler <PeekSimpleAggregate> >();
sut.Subscribe(peekHandler);
}
public void DisposalShouldThrowAsNotImplementedYet()
{
Action act = () =>
{
using (InProcessBus sut = new InProcessBus())
{
}
};
act.ShouldThrow <NotImplementedException>();
}
public async Task Test_FreeSlot_Empty3()
{
Console.WriteLine("Test_FreeSlot_Empty3");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var manager = new DownloadManager.iOS.DownloadManager(bus, repo, 3);
var wait1 = new AutoResetEvent(false);
bool queuedownload = false;
bool queueempty = false;
bool queuefull = false;
bus.Subscribe <QueueDownload> (p => {
queuedownload = true;
wait1.Set();
});
bus.Subscribe <QueueFull> (p => {
queuefull = true;
wait1.Set();
});
bus.Subscribe <QueueEmpty> (p => {
queueempty = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file1.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file2.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file3.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file4.zip", State = State.Finished
});
repo.Insert(new Download {
Url = "http://url.com/download/file5.zip", State = State.Finished
});
manager.FreeSlot(new FreeSlot {
});
wait1.WaitOne();
Assert.AreEqual(false, queuedownload);
Assert.AreEqual(false, queuefull);
Assert.AreEqual(true, queueempty);
}
public void Queue_1()
{
Console.WriteLine("Queue_1");
var bus = new InProcessBus();
var repo = new DownloadRepositoryMock();
var progressmanager = new ProgressManager(bus, repo);
progressmanager.Queue("url", (download) => {
});
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
//Bus
var bus = new InProcessBus(container);
container.Register(Component.For<IBus>().Instance(bus));
var eventStore = GetInitializedEventStore(bus);
var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector());
container.Register(Component.For<IStoreEvents>().Instance(eventStore));
container.Register(Component.For<IRepository>().Instance(repository));
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
//Bus
var bus = new InProcessBus(container);
container.Register(Component.For <IBus>().Instance(bus));
var eventStore = GetInitializedEventStore(bus);
var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector());
container.Register(Component.For <IStoreEvents>().Instance(eventStore));
container.Register(Component.For <IRepository>().Instance(repository));
}
public void Queue_1 ()
{
Console.WriteLine ("Queue_1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var progressmanager = new ProgressManager (bus, repo);
progressmanager.Queue ("url", (download) => {
});
}
public async Task Test_CancelDownloads_Empty ()
{
Console.WriteLine ("Test_CancelDownloads_Empty");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
manager.CancelDownloads (new CancelDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public static void RegisterEventStore()
{
//use a global singleton instead of IoC for this workshop
var bus = new InProcessBus();
Globals.Bus = bus;
var eventStore = GetInitializedEventStore(bus);
var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector());
Globals.EventStore = eventStore;
Globals.Repository = repository;
Globals.ApplicationService = new HostDinnerApplicationService(Globals.Repository);
}
public async Task Test_CancelDownloads_Single ()
{
Console.WriteLine ("Test_CancelDownloads_Single");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var download = new Download { State = State.Waiting };
repo.Insert (download);
manager.CancelDownloads (new CancelDownloads {
});
Assert.AreEqual (State.Finished, download.State, "First");
}
public async Task Test_ResetDownloads_Single ()
{
Console.WriteLine ("Test_ResetDownloads_Single");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var download = new Download { State = State.Waiting };
repo.Insert (download);
manager.ResetDownloads (new ResetDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public static void RegisterEventStore()
{
//use a global singleton instead of IoC for this workshop
var bus = new InProcessBus();
Globals.Bus = bus;
var eventStore = GetInitializedEventStore(bus);
var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector());
Globals.EventStore = eventStore;
Globals.Repository = repository;
Globals.ApplicationService = new HostDinnerApplicationService(Globals.Repository);
var documentStore = new DocumentStore {Url = "http://localhost:8080/", DefaultDatabase = "NerdDinner"};
documentStore.Initialize();
Globals.RavenDocumentStore = documentStore;
SetupDomainEventHandlers(bus);
}
public async Task Test_QueueUrl_CheckFreeSlot1 ()
{
Console.WriteLine ("Test_QueueUrl_CheckFreeSlot1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait = new AutoResetEvent (false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe<AlreadyQueued> (p => {
try {
alreadyQueued = true;
wait.Set();
} catch(Exception e) {
Console.WriteLine (e);
}
});
bus.Subscribe<CheckFreeSlot> (p => {
try{
checkFreeSlot = true;
wait.Set();
} catch(Exception e) {
Console.WriteLine (e);
}
});
manager.QueueUrl (new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait.WaitOne ();
Assert.AreEqual (true, checkFreeSlot);
Assert.AreEqual (false, alreadyQueued);
}
public async Task Test_FreeSlot_Empty2 ()
{
Console.WriteLine ("Test_FreeSlot_Empty2");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
bool queuedownload = false;
bool queueempty = false;
bool queuefull = false;
bus.Subscribe<QueueDownload> (p => {
queuedownload = true;
wait1.Set();
});
bus.Subscribe<QueueFull> (p => {
queuefull = true;
wait1.Set();
});
bus.Subscribe<QueueEmpty> (p => {
queueempty = true;
wait1.Set();
});
repo.Insert(new Download { Url = "http://url.com/download/file.zip", State = State.Finished });
manager.FreeSlot (new FreeSlot {
});
wait1.WaitOne ();
Assert.AreEqual (false, queuedownload);
Assert.AreEqual (false, queuefull);
Assert.AreEqual (true, queueempty);
}
public async Task Test_ResetDownloads_Multiple ()
{
Console.WriteLine ("Test_ResetDownloads_Multiple");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var waiting = new Download { State = State.Waiting };
var error = new Download { State = State.Error };
var downloading = new Download { State = State.Downloading };
var finished = new Download { State = State.Finished };
repo.Insert (waiting);
repo.Insert (downloading);
repo.Insert (error);
repo.Insert (finished);
manager.ResetDownloads (new ResetDownloads {
});
var all = repo.All ();
Assert.AreEqual (0, all.Count);
}
public async Task Test_FinishDownload_DownloadError1 ()
{
Console.WriteLine ("Test_FinishDownload_DownloadError1");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum downloaderror = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
downloaderror = p.Error;
wait1.Set();
});
manager.FinishedDownload (new FinishedDownload {
Id = 1
});
wait1.WaitOne ();
Assert.AreEqual (ErrorEnum.FinishedDownload_IdentifierNotFound, downloaderror, "Downloaderror");
}
public async Task Test_DownloadError_Error500 ()
{
Console.WriteLine ("Test_DownloadError_Error500");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Downloading };
repo.Insert (download);
manager.TaskError (new TaskError {
Id = download.Id,
Error = TaskErrorEnum.InvalidResponse,
StatusCode = 500
});
Assert.AreEqual (State.Error, download.State);
Assert.AreEqual (500, download.StatusCode);
}
public async Task Test_FreeSlot_Nowait1 ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
bool queueDownload = false;
bool queueEmpty = false;
bus.Subscribe<QueueDownload> (p => {
queueDownload = true;
wait1.Set();
});
bus.Subscribe<QueueEmpty> (p => {
queueEmpty = true;
wait1.Set();
});
manager.FreeSlot (new FreeSlot {
});
wait1.WaitOne ();
Assert.AreEqual (false, queueDownload);
Assert.AreEqual (true, queueEmpty);
}
public async Task Test_DownloadError_Error404 ()
{
Console.WriteLine ("Test_DownloadError_Error404");
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo, 3);
var wait1 = new AutoResetEvent (false);
ErrorEnum error = ErrorEnum.Empty;
bus.Subscribe<DownloadError> (p => {
error = p.Error;
wait1.Set();
});
var download = new Download { Url = "url", State = State.Downloading };
repo.Insert (download);
manager.DownloadError (new DownloadError {
Id = download.Id,
Error = ErrorEnum.DidCompleteWithError_Error,
});
wait1.WaitOne (10);
Assert.AreEqual (State.Downloading, download.State);
Assert.AreEqual (0, download.StatusCode);
}
public When_publishing_events()
{
_bus = new InProcessBus();
}
public void Setup()
{
_bus = new InProcessBus();
}
