public async Task IsFalseWhileConnectCommandExecutesWithPassword()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(x =>
{
messenger.IsConnected.Returns(true);
messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected"));
return(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")).ToTaskResult());
});
messenger.IsConnected.Returns(false);
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1"));
NetworkMessenger.Override(messenger);
var settings = new UserSettings {
AdministratorPassword = "******"
};
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings);
vm.Activator.Activate();
var coll = messenger.WhenAnyValue(x => x.IsConnected).CreateCollection();
await vm.ConnectCommand.ExecuteAsync();
Assert.Equal(new[] { false, true }, coll);
}
public async Task SmokeTest()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.IsConnected.Returns(false);
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99"))));
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1"));
NetworkMessenger.Override(messenger);
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel();
vm.Activator.Activate();
Assert.True(vm.ConnectCommand.CanExecute(null));
await vm.ConnectCommand.ExecuteAsync();
messenger.IsConnected.Returns(true);
messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected"));
Assert.False(vm.ConnectCommand.CanExecute(null));
messenger.Received(1).ConnectAsync("192.168.1.1", NetworkConstants.DefaultPort, Arg.Any <Guid>(), null);
}
public async Task ConnectsWithCustomIpAddressIfSet()
{
var settings = new UserSettings {
ServerAddress = "192.168.1.3"
};
var messenger = Substitute.For <INetworkMessenger>();
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99"))));
NetworkMessenger.Override(messenger);
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings);
vm.Activator.Activate();
ConnectionResultContainer result = await vm.ConnectCommand.ExecuteAsync();
Assert.Equal(ConnectionResult.Successful, result.ConnectionResult);
Assert.Equal(new Version("99.99.99"), result.ServerVersion);;
messenger.Received(1).ConnectAsync(settings.ServerAddress, NetworkConstants.DefaultPort,
settings.UniqueIdentifier, null);
}
public async Task IgnoresPasswordIfNotPremium()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1"));
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99"))));
NetworkMessenger.Override(messenger);
var settings = new UserSettings
{
AdministratorPassword = "******",
IsPremium = false
};
// We're not in the trial period
var installationDateFetcher = Substitute.For <IInstallationDateFetcher>();
installationDateFetcher.GetInstallationDate().Returns(DateTimeOffset.MinValue);
var clock = Substitute.For <IClock>();
clock.Now.Returns(DateTimeOffset.MinValue + AppConstants.TrialTime);
var vm = new ConnectionViewModel(settings, () => "192.168.1.2", installationDateFetcher, clock);
vm.Activator.Activate();
await vm.ConnectCommand.ExecuteAsync();
messenger.Received().ConnectAsync("192.168.1.1", settings.Port, new Guid(), null);
}
public async Task DoesntTryToDiscoverServerWithCustomIpAddressIfSet()
{
var settings = new UserSettings {
ServerAddress = "192.168.1.3"
};
bool discoverServerSubscribed = false;
var messenger = Substitute.For <INetworkMessenger>();
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>())
.Returns(Observable.Defer(() => Observable.Start(() => discoverServerSubscribed = true).Select(_ => string.Empty)));
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99"))));
NetworkMessenger.Override(messenger);
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings);
vm.Activator.Activate();
await vm.ConnectCommand.ExecuteAsync();
Assert.False(discoverServerSubscribed);
}
public void ThrottlesTimeChangesToNetworkByTime()
{
var messenger = CreateDefaultPlaylistMessenger();
NetworkMessenger.Override(messenger);
new TestScheduler().With(sched =>
{
var vm = new PlaylistViewModel();
vm.Activator.Activate();
vm.CurrentTimeSeconds = 10;
sched.AdvanceByMs(1);
vm.CurrentTimeSeconds = 20;
sched.AdvanceByMs(1);
vm.CurrentTimeSeconds = 30;
sched.AdvanceByMs(PlaylistViewModel.TimeThrottleDuration.TotalMilliseconds + 1);
messenger.ReceivedWithAnyArgs(2).SetCurrentTime(Arg.Any <TimeSpan>());
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(10));
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(30));
});
}
public void AppDoeNotDieWhenDeactivatingViewModelBeforeCommandThrows()
{
var settings = new UserSettings {
ServerAddress = "192.168.1.1"
};
var messenger = Substitute.For <INetworkMessenger>();
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Observable.Never <ConnectionResultContainer>().ToTask());
messenger.IsConnected.Returns(false);
NetworkMessenger.Override(messenger);
new TestScheduler().With(sched =>
{
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings);
vm.Activator.Activate();
vm.ConnectCommand.Execute(null);
vm.Activator.Deactivate();
sched.AdvanceByMs(ConnectionViewModel.ConnectCommandTimeout.TotalMilliseconds + 10);
});
}
private static INetworkMessenger CreateDefaultPlaylistMessenger()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.GuestSystemInfo.Returns(new GuestSystemInfo {
IsEnabled = false
});
messenger.PlaybackStateChanged.Returns(Observable.Never <NetworkPlaybackState>());
messenger.PlaylistChanged.Returns(Observable.Never <NetworkPlaylist>());
messenger.AccessPermission.Returns(NetworkAccessPermission.Admin);
NetworkMessenger.Override(messenger);
return(messenger);
}
public async Task SmokeTest()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.GuestSystemInfo.Returns(new GuestSystemInfo());
messenger.AddSongToPlaylistAsync(Arg.Any <Guid>()).Returns(new ResponseInfo().ToTaskResult());
NetworkMessenger.Override(messenger);
var songs = Helpers.SetupSongs(4).ToList();
var vm = new RemoteSongsViewModel(songs);
vm.Activator.Activate();
vm.SelectedSong = vm.Songs[2];
await vm.AddToPlaylistCommand.ExecuteAsync();
messenger.Received().AddSongToPlaylistAsync(songs[2].Guid);
}
public void SendsFirstTimeImmediatelyToNetwork()
{
var messenger = CreateDefaultPlaylistMessenger();
NetworkMessenger.Override(messenger);
new TestScheduler().With(sched =>
{
var vm = new PlaylistViewModel();
vm.Activator.Activate();
vm.CurrentTimeSeconds = 60;
sched.AdvanceByMs(1);
messenger.Received().SetCurrentTime(TimeSpan.FromSeconds(60));
});
}
public void ThrottlesTimeChangesToNetworkByCount()
{
var messenger = CreateDefaultPlaylistMessenger();
NetworkMessenger.Override(messenger);
var vm = new PlaylistViewModel();
vm.Activator.Activate();
for (int i = 1; i < PlaylistViewModel.TimeThrottleCount + 1; i++)
{
vm.CurrentTimeSeconds = i;
}
messenger.ReceivedWithAnyArgs(2).SetCurrentTime(Arg.Any <TimeSpan>());
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(1));
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(PlaylistViewModel.TimeThrottleCount));
}
public void SendsTimeToNetworkOnlyIfChangedInWindow()
{
var messenger = CreateDefaultPlaylistMessenger();
NetworkMessenger.Override(messenger);
new TestScheduler().With(sched =>
{
var vm = new PlaylistViewModel();
vm.Activator.Activate();
vm.CurrentTimeSeconds = 60;
vm.CurrentTimeSeconds = 60;
sched.AdvanceByMs(PlaylistViewModel.TimeThrottleDuration.TotalMilliseconds + 1);
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(60));
});
}
public async Task SmokeTest()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.GuestSystemInfo.Returns(new GuestSystemInfo());
NetworkMessenger.Override(messenger);
var songs = Helpers.SetupSongs(4).ToList();
var vm = new RemoteSongsViewModel(songs);
vm.Activator.Activate();
vm.SelectedSong = vm.Songs[2];
await vm.PlaySongsCommand.ExecuteAsync();
var guids = new[] { songs[2].Guid, songs[3].Guid };
messenger.Received().PlaySongsAsync(Arg.Is <IEnumerable <Guid> >(x => x.SequenceEqual(guids)));
}
public async Task ChecksMinimumServerVersion()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.IsConnected.Returns(true);
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.ServerVersionToLow, serverVersion: new Version("0.1.0"))));
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1"));
NetworkMessenger.Override(messenger);
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel();
vm.Activator.Activate();
ConnectionResultContainer result = await vm.ConnectCommand.ExecuteAsync();
Assert.Equal(ConnectionResult.ServerVersionToLow, result.ConnectionResult);
Assert.Equal(new Version("0.1.0"), result.ServerVersion);
}
public async Task SmokeTest()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.IsConnected.Returns(true);
NetworkMessenger.Override(messenger);
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel();
vm.Activator.Activate();
Assert.True(vm.DisconnectCommand.CanExecute(true));
await vm.DisconnectCommand.ExecuteAsync();
messenger.IsConnected.Returns(false);
messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected"));
Assert.False(vm.DisconnectCommand.CanExecute(null));
messenger.Received(1).Disconnect();
}
public void TimeoutTriggersConnectionFailed()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(Observable.Never <ConnectionResultContainer>().ToTask());
messenger.IsConnected.Returns(false);
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1"));
NetworkMessenger.Override(messenger);
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel();
vm.Activator.Activate();
(new TestScheduler()).With(scheduler =>
{
var connectTask = vm.ConnectCommand.ExecuteAsyncTask();
scheduler.AdvanceByMs(ConnectionViewModel.ConnectCommandTimeout.TotalMilliseconds + 1);
Assert.Equal(ConnectionResult.Timeout, connectTask.Result.ConnectionResult);
});
}
public async Task WrongPasswordTriggersConnectionFailed()
{
var messenger = Substitute.For <INetworkMessenger>();
messenger.IsConnected.Returns(false);
messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>())
.Returns(new ConnectionResultContainer(ConnectionResult.WrongPassword).ToTaskResult());
messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1"));
NetworkMessenger.Override(messenger);
var settings = new UserSettings
{
AdministratorPassword = "******",
IsPremium = true
};
ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings);
vm.Activator.Activate();
Assert.Equal(ConnectionResult.WrongPassword, (await vm.ConnectCommand.ExecuteAsync()).ConnectionResult);
}
public override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
this.Activity.ActionBar.SetTitle(Resource.String.settings);
this.userSettings = Locator.Current.GetService <UserSettings>();
this.androidSettings = Locator.Current.GetService <AndroidSettings>();
this.AddPreferencesFromResource(Resource.Layout.Settings);
var portPref = (EditTextPreference)this.FindPreference(this.GetString(Resource.String.preference_port));
portPref.EditText.InputType = InputTypes.ClassNumber;
portPref.EditText.Events().TextChanged
.Select(x => Int32.Parse(new string(x.Text.ToArray())))
.Where(x => !NetworkHelpers.IsPortValid(x))
.Subscribe(x =>
{
portPref.EditText.Error = this.GetString(Resource.String.preference_port_validation_error);
});
portPref.BindToSetting(this.userSettings, x => x.Port, x => x.Text, x => int.Parse(x.ToString()), x => x.ToString(), NetworkHelpers.IsPortValid);
var ipAddressPref = (EditTextPreference)this.FindPreference(this.GetString(Resource.String.preference_ipaddress));
ipAddressPref.EditText.InputType = InputTypes.ClassPhone;
ipAddressPref.EditText.Events().TextChanged
.Select(x => new string(x.Text.ToArray()))
.Where(x => !IsValidIpAddress(x))
.Subscribe(x =>
{
ipAddressPref.EditText.Error = this.GetString(Resource.String.preference_ipaddress_validation_error);
});
ipAddressPref.BindToSetting(this.userSettings, x => x.ServerAddress, x => x.Text, x => (string)x, x => x, IsValidIpAddress);
var saveEnergyPref = (SwitchPreference)this.FindPreference(this.GetString(Resource.String.preference_save_energy));
saveEnergyPref.BindToSetting(this.androidSettings, x => x.SaveEnergy, x => x.Checked, x => bool.Parse(x.ToString()));
var passwordPreference = (EditTextPreference)this.FindPreference(this.GetString(Resource.String.preference_administrator_password));
passwordPreference.BindToSetting(this.userSettings, x => x.AdministratorPassword, x => x.Text, x => (string)x);
this.userSettings.WhenAnyValue(x => x.IsPremium, x => x || TrialHelpers.IsInTrialPeriod(AppConstants.TrialTime))
.BindTo(passwordPreference, x => x.Enabled);
Preference premiumButton = this.FindPreference(this.GetString(Resource.String.preference_purchase_premium));
premiumButton.Events().PreferenceClick.Select(_ => this.PurchasePremium().ToObservable()
.Catch <Unit, Exception>(ex => Observable.Start(() => this.TrackInAppPurchaseException(ex))))
.Concat()
.Subscribe();
Preference restorePremiumButton = this.FindPreference(this.GetString(Resource.String.preference_restore_premium));
restorePremiumButton.Events().PreferenceClick.Select(_ => this.RestorePremium().ToObservable()
.Catch <Unit, Exception>(ex => Observable.Start(() => this.TrackInAppPurchaseException(ex))))
.Concat()
.Subscribe();
Preference versionPreference = this.FindPreference(this.GetString(Resource.String.preference_version));
versionPreference.Summary = this.Activity.PackageManager.GetPackageInfo(this.Activity.PackageName, 0).VersionName;
var virtualServerPreference = (SwitchPreference)this.FindPreference(this.GetString(Resource.String.preference_virtual_server));
virtualServerPreference.Persistent = false;
virtualServerPreference.Events().PreferenceChange
.Subscribe(x =>
{
if ((bool)x.NewValue)
{
NetworkMessenger.Override(new VirtualNetworkMessenger());
}
else
{
NetworkMessenger.ResetOverride();
}
});
#if !DEBUG && !DEVELOPMENT
var developmentCategory = (PreferenceCategory)this.FindPreference(this.GetString(Resource.String.preference_development));
var screen = (PreferenceScreen)this.FindPreference(this.GetString(Resource.String.preference_main_screen));
screen.RemovePreference(developmentCategory);
#endif
}
