private IAsyncOperation<CredentialPickerResults> SelectCredentialAsync( CredentialInteraction interaction )
        {
            Contract.Requires( interaction != null );
            Contract.Ensures( Contract.Result<IAsyncOperation<CredentialPickerResults>>() != null );

            var content = interaction == null ? string.Empty : interaction.Content.ToString();
            var options = new CredentialPickerOptions()
            {
                AlwaysDisplayDialog = AlwaysDisplayDialog,
                AuthenticationProtocol = AuthenticationProtocol,
                CallerSavesCredential = CallerSavesCredential,
                CredentialSaveOption = CredentialSaveOption,
                Caption = interaction.Title,
                Message = content,
                PreviousCredential = interaction.Credential.AsBuffer(),
            };

            if ( !string.IsNullOrEmpty( CustomAuthenticationProtocol ) )
                options.CustomAuthenticationProtocol = CustomAuthenticationProtocol;

            if ( !string.IsNullOrEmpty( TargetName ) )
                options.TargetName = TargetName;

            return CredentialPicker.PickAsync( options );
        }
        public void ConstructorShouldSetTitle()
        {
            // arrange
            var expected = "Test";

            // act
            var interaction = new CredentialInteraction( expected );
            var actual = interaction.Title;

            // assert
            Assert.Equal( expected, actual );
        }
        public void CredentialShouldWriteExpectedValue()
        {
            // arrange
            var expected = new byte[]{ 1, 2, 3 };
            var interaction = new CredentialInteraction();

            // act
            Assert.PropertyChanged( interaction, "Credential", () => interaction.Credential = expected );
            var actual = interaction.Credential;

            // assert
            Assert.Equal( expected, actual );
        }
        public void UserElectedToSaveCredentialShouldWriteExpectedValue()
        {
            // arrange
            var expected = true;
            var interaction = new CredentialInteraction();

            // act
            Assert.PropertyChanged( interaction, "UserElectedToSaveCredential", () => interaction.UserElectedToSaveCredential = expected );
            var actual = interaction.UserElectedToSaveCredential;

            // assert
            Assert.Equal( expected, actual );
        }
        public void SavedByCredentialManagerShouldWriteExpectedValue()
        {
            // arrange
            var expected = true;
            var interaction = new CredentialInteraction();

            // act
            Assert.PropertyChanged( interaction, "SavedByCredentialManager", () => interaction.SavedByCredentialManager = expected );
            var actual = interaction.SavedByCredentialManager;

            // assert
            Assert.Equal( expected, actual );
        }
        private static void InvokeCallbackCommand( CredentialInteraction selectedCredential, CredentialPickerResults result )
        {
            Contract.Requires( selectedCredential != null );
            Contract.Requires( result != null );

            INamedCommand button = null;

            if ( result.ErrorCode == 0x800704C7U )
            {
                // select cancel button
                button = selectedCredential.CancelCommand;
            }
            else
            {
                // set credential
                selectedCredential.SavedByCredentialManager = result.CredentialSaved;
                selectedCredential.UserElectedToSaveCredential = result.CredentialSaveOption == CredentialSaveOption.Selected;
                selectedCredential.Credential = result.Credential.ToArray();
                selectedCredential.DomainName = result.CredentialDomainName;
                selectedCredential.UserName = result.CredentialUserName;
                selectedCredential.Password = result.CredentialPassword;

                // select accept button
                button = selectedCredential.DefaultCommand;
            }

            // execute command for button
            if ( button != null && button.CanExecute() )
                button.Execute();
        }
        public void DomainNameShouldWriteExpectedValue()
        {
            // arrange
            var expected = "Test";
            var interaction = new CredentialInteraction();

            // act
            Assert.PropertyChanged( interaction, "DomainName", () => interaction.DomainName = expected );
            var actual = interaction.DomainName;

            // assert
            Assert.Equal( expected, actual );
        }
        public void PasswordShouldWriteExpectedValue()
        {
            // arrange
            var expected = "Test";
            var interaction = new CredentialInteraction();

            // act
            Assert.PropertyChanged( interaction, "Password", () => interaction.Password = expected );
            var actual = interaction.Password;

            // assert
            Assert.Equal( expected, actual );
        }