public RxAppTest()
{
RxApp.Initialize(new FakeDependencyResolverReactive());
}
static PropertyBindingMixins()
{
RxApp.EnsureInitialized();
_binderImplementation = new PropertyBinderImplementation();
}
public WixUiBootstrapper(IWiXEvents wixEvents, TinyIoCContainer testKernel = null, IRoutingState router = null)
{
Kernel = testKernel ?? createDefaultKernel();
Kernel.Register <IWixUiBootstrapper>(this);
Kernel.Register <IScreen>(this);
Kernel.Register(wixEvents);
Router = router ?? new RoutingState();
WiXEvents = wixEvents;
_BundledRelease = new Lazy <ReleaseEntry>(readBundledReleasesFile);
registerExtensionDlls(Kernel);
RxApp.ConfigureServiceLocator(
(type, contract) => Kernel.Resolve(type, contract),
(type, contract) => Kernel.ResolveAll(type),
(c, t, s) => Kernel.Register(t, c, s));
UserError.RegisterHandler(ex => {
if (wixEvents.Command.Display != Display.Full)
{
this.Log().Error(ex.ErrorMessage);
wixEvents.ShouldQuit();
}
var errorVm = RxApp.GetService <IErrorViewModel>();
errorVm.Error = ex;
Router.Navigate.Execute(errorVm);
return(Observable.Return(RecoveryOptionResult.CancelOperation));
});
var bundledPackageMetadata = openBundledPackage();
wixEvents.DetectPackageCompleteObs.Subscribe(eventArgs => {
var error = convertHResultToError(eventArgs.Status);
if (error != null)
{
UserError.Throw(error);
return;
}
// TODO: If the app is already installed, run it and bail
if (wixEvents.Command.Action == LaunchAction.Uninstall)
{
var updateManager = new UpdateManager("http://lol", BundledRelease.PackageName, FrameworkVersion.Net40);
var updateLock = updateManager.AcquireUpdateLock();
updateManager.FullUninstall()
.ObserveOn(RxApp.DeferredScheduler)
.Log(this, "Full uninstall")
.Finally(updateLock.Dispose)
.Subscribe(
_ => wixEvents.Engine.Plan(LaunchAction.Uninstall),
ex => UserError.Throw("Failed to uninstall application", ex),
() => wixEvents.ShouldQuit());
return;
}
if (wixEvents.Command.Action == LaunchAction.Install)
{
if (wixEvents.Command.Display != Display.Full)
{
wixEvents.Engine.Plan(LaunchAction.Install);
return;
}
var welcomeVm = RxApp.GetService <IWelcomeViewModel>();
welcomeVm.PackageMetadata = bundledPackageMetadata;
welcomeVm.ShouldProceed.Subscribe(_ => wixEvents.Engine.Plan(LaunchAction.Install));
Router.Navigate.Execute(welcomeVm);
}
});
wixEvents.PlanCompleteObs.Subscribe(eventArgs => {
var error = convertHResultToError(eventArgs.Status);
if (error != null)
{
UserError.Throw(error);
return;
}
if (wixEvents.Command.Action != LaunchAction.Install)
{
wixEvents.Engine.Apply(wixEvents.MainWindowHwnd);
return;
}
// NB: Create a dummy subject to receive progress if we're in silent mode
IObserver <int> progress = new Subject <int>();
if (wixEvents.Command.Display == Display.Full)
{
var installingVm = RxApp.GetService <IInstallingViewModel>();
progress = installingVm.ProgressValue;
installingVm.PackageMetadata = bundledPackageMetadata;
Router.Navigate.Execute(installingVm);
}
// NB: This bit of code is a bit clever. The binaries that WiX
// has installed *itself* meets the qualifications for being a
// Shimmer update directory (a RELEASES file and the corresponding
// NuGet packages).
//
// So, in order to reuse some code and not write the same things
// twice we're going to "Eigenupdate" from our own directory;
// UpdateManager will operate in bootstrap mode and create a
// local directory for us.
//
// Then, we create a *new* UpdateManager whose target is the normal
// update URL - we can then apply delta updates against the bundled
// NuGet package to get up to vCurrent. The reason we go through
// this rigamarole is so that developers don't have to rebuild the
// installer as often (never, technically).
var fxVersion = determineFxVersionFromPackage(bundledPackageMetadata);
var eigenUpdater = new UpdateManager(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), BundledRelease.PackageName, fxVersion);
var eigenLock = eigenUpdater.AcquireUpdateLock();
var eigenUpdateProgress = eigenUpdater.CheckForUpdate()
.SelectMany(x => eigenUpdater.DownloadReleases(x.ReleasesToApply))
.Finally(eigenLock.Dispose)
.Select(x => x / 2)
.Multicast(new Subject <int>());
eigenUpdateProgress.Subscribe(progress);
eigenUpdateProgress.Connect();
var realUpdateProgress = eigenUpdateProgress.TakeLast(1)
.SelectMany(_ => {
var realUpdateManager = new UpdateManager(bundledPackageMetadata.ProjectUrl.ToString(), BundledRelease.PackageName, fxVersion);
return(realUpdateManager.CheckForUpdate()
.SelectMany(updateInfo => {
return Observable.Concat(
realUpdateManager.DownloadReleases(updateInfo.ReleasesToApply).Select(x => x * 0.75),
realUpdateManager.ApplyReleases(updateInfo).Select(x => x * 0.25 + 75))
.Select(x => (int)x);
}).LoggedCatch(this, Observable.Return(100), "Failed to update to latest remote version"));
})
.Select(x => x / 2 + 50)
.Multicast(new Subject <int>());
realUpdateProgress.Subscribe(progress);
realUpdateProgress.Connect();
realUpdateProgress
.TakeLast(1)
.ObserveOn(RxApp.DeferredScheduler)
.Subscribe(
_ => wixEvents.Engine.Apply(wixEvents.MainWindowHwnd),
ex => UserError.Throw("Failed to install application", ex));
});
wixEvents.ApplyCompleteObs.Subscribe(eventArgs => {
var error = convertHResultToError(eventArgs.Status);
if (error != null)
{
UserError.Throw(error);
return;
}
if (wixEvents.Command.Display != Display.Full)
{
wixEvents.ShouldQuit();
}
// TODO: Figure out what the "main app" is and run it
});
wixEvents.ErrorObs.Subscribe(eventArgs => UserError.Throw("An installation error has occurred: " + eventArgs.ErrorMessage));
}
static IObservable <WebResponse> MakeWebRequest(
Uri uri,
Dictionary <string, string> headers = null,
string content = null,
int retries = 3,
TimeSpan?timeout = null)
{
IObservable <WebResponse> request;
var hwr = WebRequest.Create(uri);
if (headers != null)
{
foreach (var x in headers)
{
hwr.Headers[x.Key] = x.Value;
}
}
#if !SILVERLIGHT
if (RxApp.InUnitTestRunner())
{
request = Observable.Defer(() =>
{
if (content == null)
{
return(Observable.Start(() => hwr.GetResponse(), RxApp.TaskpoolScheduler));
}
var buf = Encoding.UTF8.GetBytes(content);
return(Observable.Start(() =>
{
hwr.GetRequestStream().Write(buf, 0, buf.Length);
return hwr.GetResponse();
}, RxApp.TaskpoolScheduler));
});
}
else
#endif
{
request = Observable.Defer(() =>
{
if (content == null)
{
return(Observable.FromAsyncPattern <WebResponse>(hwr.BeginGetResponse, hwr.EndGetResponse)());
}
var buf = Encoding.UTF8.GetBytes(content);
// NB: You'd think that BeginGetResponse would never block,
// seeing as how it's asynchronous. You'd be wrong :-/
var ret = new AsyncSubject <WebResponse>();
Observable.Start(() =>
{
Observable.FromAsyncPattern <Stream>(hwr.BeginGetRequestStream, hwr.EndGetRequestStream)()
.SelectMany(x => x.WriteAsync(buf, 0, buf.Length))
.SelectMany(_ => Observable.FromAsyncPattern <WebResponse>(hwr.BeginGetResponse, hwr.EndGetResponse)())
.Multicast(ret).Connect();
}, RxApp.TaskpoolScheduler);
return(ret);
});
}
return(request.Timeout(timeout ?? TimeSpan.FromSeconds(15), RxApp.TaskpoolScheduler).Retry(retries));
}
public void DepPropNotifierShouldBeFound()
{
Assert.True(RxApp.GetAllServices <ICreatesObservableForProperty>()
.Any(x => x is DependencyObjectObservableForProperty));
}
public string GetDefaultLocalMachineCacheDirectory()
{
return(RxApp.InUnitTestRunner() ?
Path.Combine(GetAssemblyDirectoryName(), "LocalBlobCache") :
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), BlobCache.ApplicationName, "BlobCache"));
}
public SecondaryViewModel(IScreen hostScreen)
{
HostScreen = hostScreen ?? RxApp.GetService <IScreen>();
}
public void IfAppIsAlreadyInstalledRunTheApp()
{
string dir, targetRootDirectory;
using (Utility.WithTempDirectory(out targetRootDirectory))
using (IntegrationTestHelper.WithFakeInstallDirectory(out dir))
{
// install version 1
var firstKernel = new TinyIoCContainer();
var firstFactory = new Mock <IProcessFactory>();
firstKernel.Register(firstFactory.Object);
var firstRouter = new RoutingState();
var firstDetectPackage = new Subject <DetectPackageCompleteEventArgs>();
var firstPlanComplete = new Subject <PlanCompleteEventArgs>();
var firstApplyComplete = new Subject <ApplyCompleteEventArgs>();
var firstError = new Subject <ErrorEventArgs>();
var firstEngine = new Mock <IEngine>();
var firstEvents = new Mock <IWiXEvents>();
firstEvents.SetupGet(x => x.DetectPackageCompleteObs).Returns(firstDetectPackage);
firstEvents.SetupGet(x => x.ErrorObs).Returns(firstError);
firstEvents.SetupGet(x => x.PlanCompleteObs).Returns(firstPlanComplete);
firstEvents.SetupGet(x => x.ApplyCompleteObs).Returns(firstApplyComplete);
firstEvents.SetupGet(x => x.Engine).Returns(firstEngine.Object);
firstEvents.SetupGet(x => x.DisplayMode).Returns(Display.Full);
firstEvents.SetupGet(x => x.Action).Returns(LaunchAction.Install);
var firstFixture = new WixUiBootstrapper(firstEvents.Object, firstKernel, firstRouter, null, dir, targetRootDirectory);
RxApp.GetAllServices <ICreatesObservableForProperty>().Any().ShouldBeTrue();
mockPerformInstall(firstRouter, firstDetectPackage, firstPlanComplete, firstApplyComplete, firstEngine);
// we expect that it opens the main exe
firstFactory.Verify(p => p.Start(It.IsAny <string>()), Times.Once());
// install version 1 again
var secondKernel = new TinyIoCContainer();
var secondFactory = new Mock <IProcessFactory>();
secondKernel.Register(secondFactory.Object);
var secondRouter = new RoutingState();
var secondDetectPackage = new Subject <DetectPackageCompleteEventArgs>();
var secondPlanComplete = new Subject <PlanCompleteEventArgs>();
var secondApplyComplete = new Subject <ApplyCompleteEventArgs>();
var secondError = new Subject <ErrorEventArgs>();
var secondEngine = new Mock <IEngine>();
var secondEvents = new Mock <IWiXEvents>();
secondEvents.SetupGet(x => x.DetectPackageCompleteObs).Returns(secondDetectPackage);
secondEvents.SetupGet(x => x.ErrorObs).Returns(secondError);
secondEvents.SetupGet(x => x.PlanCompleteObs).Returns(secondPlanComplete);
secondEvents.SetupGet(x => x.ApplyCompleteObs).Returns(secondApplyComplete);
secondEvents.SetupGet(x => x.Engine).Returns(secondEngine.Object);
secondEvents.SetupGet(x => x.DisplayMode).Returns(Display.Full);
secondEvents.SetupGet(x => x.Action).Returns(LaunchAction.Install);
var secondFixture = new WixUiBootstrapper(secondEvents.Object, secondKernel, secondRouter, null, dir, targetRootDirectory);
mockPerformInstall(secondRouter, secondDetectPackage, secondPlanComplete, secondApplyComplete, secondEngine);
var folder = Path.Combine(targetRootDirectory, "SampleUpdatingApp", "app-1.1.0.0");
Assert.True(Directory.Exists(folder));
var exe = Path.Combine(folder, "SampleUpdatingApp.exe");
// we expect that it opens the main exe again
secondFactory.Verify(
p => p.Start(exe),
Times.Once(),
"We expect a process to be executed here, but it ain't...");
}
}
public TestsTreeView()
{
this.InitializeComponent();
this.DataContext = RxApp.GetService <ITestsTreeViewModel>();
this.PerfTestConfiguration = this.GetPerfTestConfigurationFromSettings();
}
public WixUiBootstrapper(
IWiXEvents wixEvents,
TinyIoCContainer testKernel = null,
IRoutingState router = null,
IFileSystemFactory fileSystem = null,
string currentAssemblyDir = null,
string targetRootDirectory = null)
{
Kernel = testKernel ?? createDefaultKernel();
this.fileSystem = fileSystem ?? AnonFileSystem.Default;
this.currentAssemblyDir = currentAssemblyDir ?? Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
RxApp.ConfigureServiceLocator(
(type, contract) => {
this.Log().Debug("Resolving type '{0}' with contract '{1}'", type, contract);
return(String.IsNullOrEmpty(contract)
? Kernel.Resolve(type)
: Kernel.Resolve(type, contract));
},
(type, contract) => Kernel.ResolveAll(type, true),
(c, t, s) => {
this.Log().Debug("Registering type '{0}' for interface '{1}' and contract '{2}'", c, t, s);
if (String.IsNullOrEmpty(s))
{
Kernel.Register(t, c, Guid.NewGuid().ToString());
}
else
{
Kernel.Register(t, c, s);
}
});
RxRouting.ViewModelToViewFunc = findViewClassNameForViewModelName;
Kernel.Register <IWixUiBootstrapper>(this);
Kernel.Register <IScreen>(this);
Kernel.Register(wixEvents);
Router = router ?? new RoutingState();
WiXEvents = wixEvents;
_BundledRelease = new Lazy <ReleaseEntry>(readBundledReleasesFile);
registerExtensionDlls(Kernel);
UserError.RegisterHandler(ex => {
this.Log().ErrorException("Something unexpected happened", ex.InnerException);
if (wixEvents.DisplayMode != Display.Full)
{
this.Log().Error(ex.ErrorMessage);
wixEvents.ShouldQuit();
}
var errorVm = RxApp.GetService <IErrorViewModel>();
errorVm.Error = ex;
errorVm.Shutdown.Subscribe(_ => wixEvents.ShouldQuit());
errorVm.OpenLogsFolder.Subscribe(_ => openLogsFolder());
RxApp.DeferredScheduler.Schedule(() => Router.Navigate.Execute(errorVm));
return(Observable.Return(RecoveryOptionResult.CancelOperation));
});
bundledPackageMetadata = new Lazy <IPackage>(openBundledPackage);
wixEvents.DetectPackageCompleteObs.Subscribe(eventArgs => {
this.Log().Info("DetectPackageCompleteObs: got id: '{0}', state: '{1}', status: '{2}'", eventArgs.PackageId, eventArgs.State, eventArgs.Status);
var error = convertHResultToError(eventArgs.Status);
if (error != null)
{
UserError.Throw(error);
return;
}
// we now have multiple applications in the chain
// only run this code after the last entry in the chain
if (eventArgs.PackageId != "UserApplicationId")
{
return;
}
if (wixEvents.Action == LaunchAction.Uninstall)
{
if (wixEvents.DisplayMode != Display.Full)
{
this.Log().Info("Squirrel is doing a silent uninstall! Sneaky!");
wixEvents.Engine.Plan(LaunchAction.Uninstall);
return;
}
this.Log().Info("Squirrel is doing an uninstall! Sadface!");
var uninstallVm = RxApp.GetService <IUninstallingViewModel>();
Router.Navigate.Execute(uninstallVm);
wixEvents.Engine.Plan(LaunchAction.Uninstall);
return;
}
// TODO: If the app is already installed, run it and bail
// If Display is silent, we should just exit here.
if (wixEvents.Action == LaunchAction.Install)
{
if (wixEvents.DisplayMode != Display.Full)
{
this.Log().Info("Squirrel is doing a silent install! Sneaky!");
wixEvents.Engine.Plan(LaunchAction.Install);
return;
}
this.Log().Info("We are doing an UI install! Huzzah!");
var welcomeVm = RxApp.GetService <IWelcomeViewModel>();
welcomeVm.PackageMetadata = bundledPackageMetadata.Value;
welcomeVm.ShouldProceed.Subscribe(_ => wixEvents.Engine.Plan(LaunchAction.Install));
// NB: WiX runs a "Main thread" that all of these events
// come back on, and a "UI thread" where it actually runs
// the WPF window. Gotta proxy to the UI thread.
RxApp.DeferredScheduler.Schedule(() => Router.Navigate.Execute(welcomeVm));
}
});
var executablesToStart = Enumerable.Empty <string>();
wixEvents.PlanCompleteObs.Subscribe(eventArgs => {
this.Log().Info("PlanCompleteObs: got status: '{0}'", eventArgs.Status);
var installManager = new InstallManager(BundledRelease, targetRootDirectory);
var error = convertHResultToError(eventArgs.Status);
if (error != null)
{
UserError.Throw(error);
return;
}
if (wixEvents.Action == LaunchAction.Uninstall)
{
var task = installManager.ExecuteUninstall(BundledRelease.Version);
task.Subscribe(
_ => wixEvents.Engine.Apply(wixEvents.MainWindowHwnd),
ex => UserError.Throw(new UserError("Failed to uninstall", ex.Message, innerException: ex)));
// the installer can close before the uninstall is done
// which means the UpdateManager is not disposed correctly
// which means an error is thrown in the destructor
//
// let's wait for it to finish
//
// oh, and .Wait() is unnecesary here
// because the subscriber handles an exception
var result = task.FirstOrDefault();
return;
}
IObserver <int> progress = null;
if (wixEvents.DisplayMode == Display.Full)
{
var installingVm = RxApp.GetService <IInstallingViewModel>();
progress = installingVm.ProgressValue;
installingVm.PackageMetadata = bundledPackageMetadata.Value;
RxApp.DeferredScheduler.Schedule(() => Router.Navigate.Execute(installingVm));
}
installManager.ExecuteInstall(this.currentAssemblyDir, bundledPackageMetadata.Value, progress).Subscribe(
toStart => {
executablesToStart = toStart ?? executablesToStart;
wixEvents.Engine.Apply(wixEvents.MainWindowHwnd);
},
ex => UserError.Throw("Failed to install application", ex));
});
wixEvents.ApplyCompleteObs.Subscribe(eventArgs => {
this.Log().Info("ApplyCompleteObs: got restart: '{0}', result: '{1}', status: '{2}'", eventArgs.Restart, eventArgs.Result, eventArgs.Status);
var error = convertHResultToError(eventArgs.Status);
if (error != null)
{
UserError.Throw(error);
return;
}
if (wixEvents.DisplayMode == Display.Full && wixEvents.Action == LaunchAction.Install)
{
var processFactory = Kernel.Resolve <IProcessFactory>();
foreach (var path in executablesToStart)
{
processFactory.Start(path);
}
}
wixEvents.ShouldQuit();
});
wixEvents.ErrorObs.Subscribe(
eventArgs => {
this.Log().Info("ErrorObs: got id: '{0}', result: '{1}', code: '{2}'", eventArgs.PackageId, eventArgs.Result, eventArgs.ErrorCode);
UserError.Throw("An installation error has occurred: " + eventArgs.ErrorMessage);
});
wixEvents.Engine.Detect();
}
public ObservedChangedExtensionsTest()
{
RxApp.Initialize(new FakeDependencyResolverReactive());
}
public PlayViewModel(IScreen screen, ILoginMethods loginMethods)
{
HostScreen = screen;
TogglePlay = new ReactiveCommand();
Logout = new ReactiveCommand();
Search = new ReactiveCommand();
// XXX: God I hate that I have to do this
Observable.Never <Song>().ToProperty(this, x => x.CurrentSong);
Observable.Never <IEnumerable <Song> >().ToProperty(this, x => x.Queue);
Observable.Never <IEnumerable <SongTileViewModel> >().ToProperty(this, x => x.AllSongs);
this.WhenNavigatedTo(() => {
var playApi = loginMethods.CurrentAuthenticatedClient;
if (playApi == null)
{
loginMethods.EraseCredentialsAndNavigateToLogin();
return(null);
}
// Get the Listen URL or die trying
Observable.Defer(playApi.ListenUrl)
.Timeout(TimeSpan.FromSeconds(30), RxApp.TaskpoolScheduler)
.Retry()
.ToProperty(this, x => x.ListenUrl);
var pusherSubj = playApi.ConnectToSongChangeNotifications()
.Retry(25)
.Multicast(new Subject <Unit>());
var shouldUpdate = Observable.Defer(() =>
pusherSubj.Take(1).Timeout(TimeSpan.FromMinutes(2.0), RxApp.TaskpoolScheduler)).Catch(Observable.Return(Unit.Default))
.Repeat()
.StartWith(Unit.Default)
.Multicast(new Subject <Unit>());
var nowPlaying = shouldUpdate.SelectMany(_ => playApi.NowPlaying()).Multicast(new Subject <Song>());
shouldUpdate.SelectMany(_ => playApi.Queue())
.Catch(Observable.Return(Enumerable.Empty <Song>()))
.ToProperty(this, x => x.Queue);
nowPlaying
.Catch(Observable.Return(new Song()))
.ToProperty(this, x => x.CurrentSong);
this.WhenAny(x => x.CurrentSong, x => x.Queue,
(song, queue) => (queue.Value != null && song.Value != null ? queue.Value.StartWith(song.Value) : Enumerable.Empty <Song>()))
.Do(x => this.Log().Info("Found {0} items", x.Count()))
.Select(x => x.Select(y => new SongTileViewModel(y, loginMethods.CurrentAuthenticatedClient)
{
QueueSongVisibility = Visibility.Collapsed
}))
.ToProperty(this, x => x.AllSongs);
MessageBus.Current.RegisterMessageSource(this.WhenAny(x => x.IsPlaying, x => x.Value), "IsPlaying");
var ret = new CompositeDisposable();
ret.Add(nowPlaying.Connect());
ret.Add(shouldUpdate.Connect());
ret.Add(pusherSubj.Connect());
return(ret);
});
Logout.Subscribe(_ => loginMethods.EraseCredentialsAndNavigateToLogin());
Search.Subscribe(_ => screen.Router.Navigate.Execute(RxApp.GetService <ISearchViewModel>()));
}
public ReactiveNotifyPropertyChangedExtenionsTest()
{
RxApp.Initialize(new FakeDependencyResolverReactive());
}
protected static string GetDefaultLocalMachineCacheDirectory()
{
return(RxApp.InUnitTestRunner() ?
Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "LocalBlobCache") :
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), BlobCache.ApplicationName, "BlobCache"));
}
public MainViewModel(IScreen hostScreen)
{
HostScreen = hostScreen ?? RxApp.GetService <IScreen>();
}
public static void Go <T>(this INavigateCommand This, string key = null)
where T : IRoutableViewModel
{
This.Execute(RxApp.GetService <T>(key));
}
public App()
{
BlobCache.ApplicationName = "DataGridSerialization";
RxApp.ConfigureServiceLocator((t, s) => null, (t, s) => null, (c, t, s) => { });
}
