public void InitializeSync()
{
if (Manager.SharedInstance.GetDatabase(DatabaseName) == null)
{
return;
}
UninitializeSync();
IAuthenticator auth =
string.IsNullOrWhiteSpace(Username)
? null
: AuthenticatorFactory.CreateBasicAuthenticator(Username, Password);
pull = Manager.SharedInstance.GetDatabase(DatabaseName).CreatePullReplication(RemoteSyncUrl);
if (auth != null)
{
pull.Authenticator = auth;
}
push = Manager.SharedInstance.GetDatabase(DatabaseName).CreatePushReplication(RemoteSyncUrl);
if (auth != null)
{
push.Authenticator = auth;
}
pull.Continuous = push.Continuous = true;
pull.Changed += ReplicationProgress;
push.Changed += ReplicationProgress;
pull.Start();
push.Start();
}
/// <summary>
/// Sets up the scan job.
/// </summary>
/// <param name="device">The device.</param>
protected override void SetupJob(IDevice device)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
UpdateStatus(string.Format("Setting up device at address {0} for user {1}", device.Address, ExecutionData.Credential.UserName));
string entryButtonTitle = "My workflow (FutureSmart)";
IAuthenticator auth = AuthenticatorFactory.Create(device, ExecutionData.Credential, AuthenticationProvider.Auto);
auth.WorkflowLogger = WorkflowLogger;
AuthenticationMode am = (_data.ApplicationAuthentication == false) ? AuthenticationMode.Eager : AuthenticationMode.Lazy;
if (am.Equals(AuthenticationMode.Eager))
{
UpdateStatus("Authenticating by pressing the Sign In button first.");
}
else
{
UpdateStatus(string.Format("Authenticating by pressing the {0} button first.", entryButtonTitle));
}
_hpecApp = HpecFactory.Create(device);
_hpecApp.WorkflowLogger = WorkflowLogger;
_hpecApp.Launch(auth, am);
}
/// <summary>
/// Initializes the authenticator that will be used in the run, including setting up the badgebox if needed.
/// </summary>
/// <param name="provider">The authentication provider to create</param>
/// <param name="device">The device that will be used for the run.</param>
private IAuthenticator GetAuthenticator(AuthenticationProvider provider, IDevice device)
{
IAuthenticator authenticator = AuthenticatorFactory.Create(_deviceInfo.AssetId, device, provider, _executionData);
authenticator.WorkflowLogger = _workflowLogger;
return(authenticator);
}
/// <summary>
/// Starts a replication for the session
/// </summary>
/// <param name="username">The username to use for the replication</param>
/// <param name="password">The password to use for replication auth (optional)</param>
public static void StartReplication(string username, string password = null)
{
var authenticator = default(IAuthenticator);
if (username != null && password != null)
{
authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, password);
}
var db = AppWideManager.GetDatabase(username);
var pusher = db.CreatePushReplication(SyncGatewayUrl);
pusher.Continuous = true;
pusher.Authenticator = authenticator;
pusher.Changed += HandleReplicationChanged;
var puller = db.CreatePullReplication(SyncGatewayUrl);
puller.Continuous = true;
puller.Authenticator = authenticator;
puller.Changed += HandleReplicationChanged;
pusher.Start();
puller.Start();
_pusher = pusher;
_puller = puller;
}
public void TestGetAuthenticationHeaderValue()
{
var username1 = "username1";
var password1 = "password1";
var credParam1 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username1, password1)));
var auth = AuthenticatorFactory.CreateBasicAuthenticator(username1, password1);
var authHeader = AuthUtils.GetAuthenticationHeaderValue(auth, null);
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam1, authHeader.Parameter);
var username2 = "username2";
var password2 = "password2";
var credParam2 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username2, password2)));
var userinfo = username2 + ":" + password2;
var uri = new Uri("http://" + userinfo + "@couchbase.com");
var request = new HttpRequestMessage(HttpMethod.Get, uri);
authHeader = AuthUtils.GetAuthenticationHeaderValue(auth, request.RequestUri);
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam2, authHeader.Parameter);
uri = new Uri("http://www.couchbase.com");
request = new HttpRequestMessage(HttpMethod.Get, uri);
authHeader = AuthUtils.GetAuthenticationHeaderValue(null, request.RequestUri);
Assert.IsNull(authHeader);
auth = AuthenticatorFactory.CreateFacebookAuthenticator("1234");
authHeader = AuthUtils.GetAuthenticationHeaderValue(auth, null);
Assert.IsNull(authHeader);
}
public void Replication()
{
var url = new Uri("http://127.0.0.1:5984/couchbaseevents-xam");
var push = db.CreatePushReplication(url);
var pull = db.CreatePullReplication(url);
var auth = AuthenticatorFactory.CreateBasicAuthenticator("xamarain", "xamarain");
push.Authenticator = auth;
pull.Authenticator = auth;
push.Continuous = true;
pull.Continuous = true;
push.Changed += (sender, e) =>
{
// Will be called when the push replication status changes
Console.WriteLine(e.Username);
Console.WriteLine(e.ChangesCount);
Console.WriteLine(e.Status);
};
pull.Changed += (sender, e) =>
{
// Will be called when the pull replication status changes
Console.WriteLine(e.Username);
Console.WriteLine(e.ChangesCount);
Console.WriteLine(e.Status);
};
pull.Start();
push.Start();
}
public IAuthenticator CreateAuthenticator(ReplicationDriverContext context)
{
return(AuthenticatorFactory.CreateBasicAuthenticator(
username: this._credentials.Item1,
password: this._credentials.Item2
));
}
public void TestBasicAuthenticationWrongPassword()
{
if (!Boolean.Parse((string)GetProperty("replicationTestsEnabled")))
{
Assert.Inconclusive("Server tests disabled.");
return;
}
var username = "******";
var password = "******";
var wrongPassword = "******";
AddUser(username, password);
CreateDocuments(database, 10);
var url = GetReplicationURLWithoutCredentials();
var replicator = database.CreatePushReplication(url);
replicator.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, wrongPassword);
Assert.IsNotNull(replicator);
Assert.IsNotNull(replicator.Authenticator);
Assert.IsTrue(replicator.Authenticator is BasicAuthenticator);
RunReplication(replicator);
var lastError = replicator.LastError;
Assert.IsNotNull(lastError);
}
public void TestOpenIDExpiredToken()
{
if (_storageType != StorageEngineTypes.SQLite)
{
return;
}
var remoteUri = new Uri($"http://{GetReplicationServer ()}:{GetReplicationPort ()}/openid_db");
Assert.IsTrue(OpenIDAuthenticator.ForgetIDTokens(remoteUri));
var callbackInvoked = false;
var auth = (OpenIDAuthenticator)AuthenticatorFactory.CreateOpenIDAuthenticator(manager, (login, authBase, cont) =>
{
AssertValidOIDCLogin(login, authBase, remoteUri);
Assert.IsFalse(callbackInvoked);
callbackInvoked = true;
cont(null, null);
});
// Set bogus ID and refresh tokens, so first the session check will fail, then the attempt
// to refresh the ID token will fail. Finally the callback above will be called.
auth.IDToken = "BOGUS_ID";
auth.RefreshToken = "BOGUS_REFRESH";
var pullError = PullWithOIDCAuth(remoteUri, auth);
Assert.IsTrue(callbackInvoked);
Assert.IsNotNull(pullError);
Assert.IsInstanceOf(typeof(OperationCanceledException), pullError);
}
public void TestGetAuthenticationHeaderValue()
{
var username1 = "username1";
var password1 = "password1";
var credParam1 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username1, password1)));
var auth = AuthenticatorFactory.CreateBasicAuthenticator(username1, password1) as BasicAuthenticator;
var authHeader = auth.AuthorizationHeaderValue;
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam1, authHeader.Split(' ')[1]);
var username2 = "username2";
var password2 = "password2";
var credParam2 = Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username2, password2)));
var userinfo = username2 + ":" + password2;
var uri = new Uri("http://" + userinfo + "@couchbase.com");
auth = (BasicAuthenticator)AuthenticatorFactory.CreateFromUri(uri);
authHeader = auth.AuthorizationHeaderValue;
Assert.IsNotNull(authHeader);
Assert.AreEqual(credParam2, authHeader.Split(' ')[1]);
uri = new Uri("http://www.couchbase.com");
auth = (BasicAuthenticator)AuthenticatorFactory.CreateFromUri(uri);
Assert.IsNull(auth);
var auth2 = AuthenticatorFactory.CreateFacebookAuthenticator("1234") as ICustomHeadersAuthorizer;
Assert.IsNull(auth2);
}
private static Replication SetupReplication(Manager manager, bool continuous, bool createTarget, Uri remoteUri, bool isPull, string user, string password)
{
if (remoteUri == null)
{
return(null);
}
var databaseName = remoteUri.Segments.Last();
var authenticator = default(IAuthenticator);
if (user != null && password != null)
{
Console.WriteLine("Setting session credentials for user '{0}'", user);
authenticator = AuthenticatorFactory.CreateBasicAuthenticator(user, password);
}
if (isPull)
{
Console.WriteLine("Pulling from <{0}> --> {1}", remoteUri, databaseName);
}
else
{
Console.WriteLine("Pushing {0} --> <{1}>", databaseName, remoteUri);
}
var db = manager.GetExistingDatabase(databaseName);
if (isPull && db == null)
{
db = manager.GetDatabase(databaseName);
}
if (db == null)
{
Console.Error.WriteLine("Couldn't open database {0}", databaseName);
return(null);
}
var repl = isPull ? db.CreatePullReplication(remoteUri) : db.CreatePushReplication(remoteUri);
repl.Continuous = continuous;
repl.CreateTarget = createTarget;
repl.Authenticator = authenticator;
repl.Changed += (sender, e) =>
{
Console.WriteLine("*** Replicator status changed ({0} {1}/{2}) ***", e.Status, e.CompletedChangesCount, e.ChangesCount);
if (e.LastError != null)
{
Console.Error.WriteLine("*** Replicator reported error ***", e);
}
else if (e.Status == ReplicationStatus.Stopped)
{
Console.WriteLine("*** Replicator finished ***");
}
};
repl.Start();
return(repl);
}
private InteractiveAuthenticatorBase CreateAuthenticator(string key)
{
var af = new AuthenticatorFactory();
var parts = key.Split('|');
var a = af.CreateInteractiveAuthenticator(parts[0], parts[1]);
return(a);
}
/// <summary>
/// Initializes the authenticator that will be used in the run.
/// </summary>
/// <param name="provider">The authentication provider to create.</param>
/// <param name="device">The device that will be used for the run.</param>
protected void InitializeAuthenticator(AuthenticationProvider provider, IDevice device)
{
// Only AutoStore authentication (Lazy) is allowed by the application at this time.
// Also, card auth is not supported at this time.
Authenticator = AuthenticatorFactory.Create(device, ExecutionData.Credential, provider);
Authenticator.WorkflowLogger = WorkflowLogger;
}
public void Multiple_Create_calls_should_return_different_authenticators_instances()
{
var subject = new AuthenticatorFactory(() => new PlainAuthenticator(new UsernamePasswordCredential("source", "user", "password"), serverApi: null));
var authenticator1 = subject.Create();
var authenticator2 = subject.Create();
authenticator1.Should().NotBeSameAs(authenticator2);
}
public void Create_should_create_authenticator_based_on_the_provided_delegate()
{
var subject = new AuthenticatorFactory(() => new PlainAuthenticator(new UsernamePasswordCredential("source", "user", "password"), serverApi: null));
var authenticator = subject.Create();
var typedAuthenticator = authenticator.Should().BeOfType <PlainAuthenticator>().Subject;
typedAuthenticator.DatabaseName.Should().Be("source");
}
private void PerformLogin(object sender, EventArgs e)
{
((Button)sender).IsEnabled = false;
StartPull(r =>
{
var callback = OpenIDAuthenticator.GetOIDCCallback();
r.Authenticator = AuthenticatorFactory.CreateOpenIDAuthenticator(Manager.SharedInstance, callback);
_changedHandler = CheckAuthCodeLoginComplete;
});
}
/// <summary>
/// Creates a derived key stream from which a derived key can be read.
/// </summary>
/// <param name="key">The key to derive from.</param>
/// <param name="salt">
/// The salt.
/// A unique salt means a unique scrypt stream, even if the original key is identical.
/// </param>
/// <param name="cost">
/// The cost parameter, typically a fairly large number such as 262144.
/// Memory usage and CPU time scale approximately linearly with this parameter.
/// </param>
/// <param name="blockSize">
/// The mixing block size, typically 8.
/// Memory usage and CPU time scale approximately linearly with this parameter.
/// </param>
/// <param name="parallel">
/// The level of parallelism, typically 1.
/// CPU time scales approximately linearly with this parameter.
/// </param>
/// <param name="maxThreads">
/// The maximum number of threads to spawn to derive the key.
/// This is limited by the <paramref name="parallel" /> value.
/// <c>null</c> will use as many threads as possible.
/// </param>
/// <returns>The derived key stream.</returns>
public static Pbkdf2 GetStream(byte[] key, byte[] salt,
int cost, int blockSize, int parallel, int?maxThreads)
{
byte[] B = GetEffectivePbkdf2Salt(key, salt, cost, blockSize, parallel, maxThreads);
IMac hmac = AuthenticatorFactory.CreateHmacPrimitive(HashFunction.Sha256, key, null);
var kdf = new Pbkdf2(hmac, B, 1);
//Security.Clear(B);
Array.Clear(B, 0, B.Length);
return(kdf);
}
internal async Task OpenAsync(CancellationToken cancellationToken)
{
logger.Debug("Open Session");
if (authenticator == null)
{
authenticator = AuthenticatorFactory.GetAuthenticator(this);
}
await authenticator.AuthenticateAsync(cancellationToken).ConfigureAwait(false);
}
internal void Open()
{
logger.Debug("Open Session");
if (authenticator == null)
{
authenticator = AuthenticatorFactory.GetAuthenticator(this);
}
authenticator.Authenticate();
}
public void Authentication(string appName)
{
// Create Authenticator
IAuthenticator auth = AuthenticatorFactory.Create(_device, _credential, AuthenticationProvider.Windows);
var preparationManager = new SiriusUIv2PreparationManager(_device);
try
{
preparationManager.InitializeDevice(true);
switch (appName)
{
case "Sign In":
throw new DeviceWorkflowException("Sign In from home screen not supported for this device");
case "HP AC Secure Pull Print":
case "My workflow (FutureSmart)":
case "Pull Print":
_device.ControlPanel.PressByValue("Apps");
WaitForScreenLabel("view_oxpd_home", TimeSpan.FromSeconds(30));
string displayedTitle = GetButtonDisplayedTitle(appName);
_device.ControlPanel.ScrollToItemByValue("oxpd_home_table", displayedTitle);
_device.ControlPanel.PressByValue(displayedTitle);
WaitForScreenLabel("view_sips_form", TimeSpan.FromSeconds(30));
auth.Authenticate();
break;
default:
AuthenticationHelper.LaunchApp(_device, appName, auth);
break;
}
}
catch (Exception ex)
{
var currentScreen = _device.ControlPanel.ActiveScreenLabel();
ExecutionServices.SystemTrace.LogDebug("Active screen = " + currentScreen);
throw new DeviceInvalidOperationException($"Unable to authenticate: current screen = {currentScreen}", ex);
}
finally
{
try
{
preparationManager.NavigateHome();
}
catch
{
//ignored
}
}
}
public static void Main(string[] args)
{
var syncGatewayUrl = new Uri("http://localhost:4984/db/");
Manager manager = Manager.SharedInstance;
Database airlineDb = manager.GetDatabase("airline");
Database routeDb = manager.GetDatabase("route");
Database airportDb = manager.GetDatabase("airport");
Database landmarkDb = manager.GetDatabase("landmark");
Database hotelDb = manager.GetDatabase("hotel");
// Total docs: 31591
var testDbs = new TestDatabase[] {
new TestDatabase(airlineDb, "airline", "pass", 187),
new TestDatabase(routeDb, "route", "pass", 24024),
new TestDatabase(airportDb, "airport", "pass", 1968),
new TestDatabase(landmarkDb, "landmark", "pass", 4495),
new TestDatabase(hotelDb, "hotel", "pass", 917),
};
// Start continuous push / pull replications for each database
foreach (var testDb in testDbs)
{
IAuthenticator replicationAuth = AuthenticatorFactory.CreateBasicAuthenticator(testDb.UserName, testDb.Password);
Replication pullReplication = testDb.Database.CreatePullReplication(syncGatewayUrl);
pullReplication.Authenticator = replicationAuth;
pullReplication.Continuous = true;
pullReplication.Start();
Replication pushReplication = testDb.Database.CreatePushReplication(syncGatewayUrl);
pushReplication.Authenticator = replicationAuth;
pushReplication.Continuous = true;
pushReplication.Start();
}
// Wait for replication to stop
var timeout = TimeSpan.FromMinutes(20);
// Poll until all dbs have the expected number of docs
WaitForImport(testDbs, timeout);
// Update each doc via Lite
TouchAllDocs(testDbs);
// Run python script to update all the docs via the SDK
Console.WriteLine("\nWaiting for SDK to perform updates ...");
var line = Console.ReadLine();
// Wait for replication to stop
WaitForSDKUpdates(testDbs, timeout);
}
public void Authentication(string appName)
{
// Create Authenticator
IAuthenticator auth = AuthenticatorFactory.Create(_device, _credential, AuthenticationProvider.Auto);
try
{
var jediWindJammerPrepManager = new JediWindjammerPreparationManager(_device);
jediWindJammerPrepManager.InitializeDevice(true);
switch (appName)
{
case "Sign In":
_device.ControlPanel.PressToNavigate("mSignInButton", "SignInForm", ignorePopups: true);
if (_device.ControlPanel.GetControls().Contains("m_RadioButton"))
{
//Using PressScreen since the small screen doesn't seem to like the mOKButton
_device.ControlPanel.PressScreen(250, 250);
}
auth.Authenticate();
break;
case "Follow-You Printing":
case "HP AC Secure Pull Print":
case "My workflow (FutureSmart)":
case "Pull Print":
case "Scan To Me":
case "Scan To My Files":
case "Scan To Folder":
case "Public Distributions":
case "Routing Sheet":
case "Personal Distributions":
_device.ControlPanel.ScrollPressWait("mAccessPointDisplay", "Title", appName, "SignInForm", StringMatch.StartsWith, TimeSpan.FromSeconds(60));
auth.Authenticate();
break;
default:
AuthenticationHelper.LaunchApp(_device, appName, auth);
break;
}
}
catch (Exception ex)
{
var currentScreen = _device.ControlPanel.CurrentForm();
string message = $"Unable to authenticate. Verify EWS authentication configuration and that {appName} button invokes the intended auth method. (current screen: {currentScreen}";
ExecutionServices.SystemTrace.LogDebug(message + $"; Exception: {ex.Message}");
throw new DeviceInvalidOperationException(message + ")", ex);
}
}
protected void RunDiscreteVectorTest(int number, DiscreteVectorDigestTestCase testCase)
{
var hashFunctionEnum = testCase.Primitive;
IHash authenticator = AuthenticatorFactory.CreateHashPrimitive(hashFunctionEnum);
authenticator.BlockUpdate(testCase.Message, 0, testCase.Message.Length);
var output = new byte[authenticator.OutputSize];
authenticator.DoFinal(output, 0);
Assert.IsTrue(testCase.Output.SequenceEqualShortCircuiting(output),
"Test #{0} (\"{1}\") failed!", number, testCase.Name);
}
private void StartReplications()
{
_pull = _db.CreatePullReplication(CreateSyncUri());
_push = _db.CreatePushReplication(CreateSyncUri());
var authenticator = AuthenticatorFactory.CreateBasicAuthenticator(User, Password);
_pull.Authenticator = authenticator;
_push.Authenticator = authenticator;
_pull.Continuous = true;
_push.Continuous = true;
// _pull.Start();
// _push.Start();
_push.Changed += OnPushChanged;
}
public static void KeyExchange(ArraySegment <byte> sharedKey, ArraySegment <byte> publicKey, ArraySegment <byte> privateKey, bool naclCompat = false)
{
if (sharedKey.Array == null)
{
throw new ArgumentNullException("sharedKey.Array");
}
if (publicKey.Array == null)
{
throw new ArgumentNullException("publicKey.Array");
}
if (privateKey.Array == null)
{
throw new ArgumentNullException("privateKey");
}
if (sharedKey.Count != SharedKeySizeInBytes)
{
throw new ArgumentException("sharedKey.Count != 32");
}
if (publicKey.Count != PublicKeySizeInBytes)
{
throw new ArgumentException("publicKey.Count != 32");
}
if (privateKey.Count != ExpandedPrivateKeySizeInBytes)
{
throw new ArgumentException("privateKey.Count != 64");
}
FieldElement montgomeryX, edwardsY, edwardsZ, sharedMontgomeryX;
FieldOperations.fe_frombytes(out edwardsY, publicKey.Array, publicKey.Offset);
FieldOperations.fe_1(out edwardsZ);
Curve25519.EdwardsToMontgomeryX(out montgomeryX, ref edwardsY, ref edwardsZ);
IHash hasher = AuthenticatorFactory.CreateHashPrimitive(HashFunction.Sha512);
hasher.BlockUpdate(privateKey.Array, privateKey.Offset, 32);
byte[] h = new byte[64];
hasher.DoFinal(h, 0);
ScalarOperations.sc_clamp(h, 0);
MontgomeryOperations.scalarmult(out sharedMontgomeryX, h, 0, ref montgomeryX);
h.SecureWipe();
FieldOperations.fe_tobytes(sharedKey.Array, sharedKey.Offset, ref sharedMontgomeryX);
if (naclCompat)
{
Curve25519.KeyExchangeOutputHashNaCl(sharedKey.Array, sharedKey.Offset);
}
}
public virtual void StartReplicationSyncWithFacebookLogin(string accessToken, string
email)
{
Authenticator facebookAuthenticator = AuthenticatorFactory.CreateFacebookAuthenticator
(accessToken);
Replication[] replications = CreateReplications();
Replication pullRep = replications[0];
Replication pushRep = replications[1];
pullRep.SetAuthenticator(facebookAuthenticator);
pushRep.SetAuthenticator(facebookAuthenticator);
pullRep.Start();
pushRep.Start();
Log.V(Tag, "Start Replication Sync ...");
}
/// <summary>
/// Creates a new instance of the <see cref="ApiAccessorBase" /> class
/// with the API endpoint relative path, base API path
/// and the API configuration is specified (or use <see cref="Configuration.Default" />).
/// </summary>
/// <param name="relativePath">The API endpoint relative path.</param>
/// <param name="basePath">The base API path.</param>
/// <param name="configuration">The API configuration.</param>
public ApiAccessorBase(string relativePath, string basePath = null, Configuration configuration = null)
{
Configuration = configuration ?? Configuration.Default;
Path = relativePath ?? throw new ArgumentNullException(nameof(relativePath));
ExceptionFactory = Configuration.DefaultExceptionFactory;
AuthenticatorFactory = Configuration.DefaultAuthenticatorFactory;
if (Uri.TryCreate(basePath, UriKind.Absolute, out var baseUrl))
{
_restClient = new RestClient(baseUrl);
}
else
{
_restClient = new RestClient(Configuration.DEFAULT_BASE_PATH);
}
}
public void TestReplicatorErrorStatus()
{
var email = "*****@*****.**";
var accessToken = "fake_access_token";
var remoteUrl = GetReplicationURL().ToString();
FacebookAuthorizer.RegisterAccessToken(accessToken, email, remoteUrl);
var replicator = database.CreatePullReplication(GetReplicationURL());
replicator.Authenticator = AuthenticatorFactory.CreateFacebookAuthenticator(accessToken);
RunReplication(replicator);
Assert.IsNotNull(replicator.LastError);
}
/// <summary>
/// Selects a control panel activity to run and calls the appropriate method to run it
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
private PluginExecutionResult RunControlPanelActivity(IDevice device)
{
UpdateStatus("Running Control Panel Activity...");
PluginExecutionResult controlPanelActivityResult = new PluginExecutionResult(PluginResult.Failed);
//Initializing the authenticator
IAuthenticator authenticator = AuthenticatorFactory.Create(device, ExecutionData.Credential);
authenticator.WorkflowLogger = WorkflowLogger;
object controlPanelData = null;
//Selecting a random control Panel activity.
Type ControlPanelActivityToRun = SelectRandomActivity(_data.SelectedControlPanelActivities);
Attribute[] attributes = Attribute.GetCustomAttributes(ControlPanelActivityToRun);
foreach (Attribute attr in attributes)
{
if (attr is ControlPanelActivity)
{
ControlPanelActivity controlPanelAttribute = (ControlPanelActivity)attr;
switch (controlPanelAttribute.ActivityName)
{
case "Copy":
//Copy activity is selected
UpdateStatus("Selected Control Panel Activity: Copy");
controlPanelData = _data.SelectedControlPanelActivities.OfType <CopyActivityData>().Single();
controlPanelActivityResult = ExecuteCopy(device, controlPanelData, authenticator);
break;
case "Scan":
//Scan activity is selected
controlPanelData = _data.SelectedControlPanelActivities.OfType <ScanActivityData>().Single();
controlPanelActivityResult = ExecuteScan(device, controlPanelData, authenticator);
break;
case "Fax":
//Fax activity is selected
UpdateStatus("Selected Control Panel Activity: Fax");
controlPanelData = _data.SelectedControlPanelActivities.OfType <FaxActivityData>().Single();
controlPanelActivityResult = ExecuteFax(device, controlPanelData, authenticator);
break;
}
}
}
return(controlPanelActivityResult);
}
public void TestBasicAuthenticationWrongPassword()
{
if (!Boolean.Parse((string)Runtime.Properties["replicationTestsEnabled"]))
{
Assert.Inconclusive("Server tests disabled.");
return;
}
var username = "******";
var password = "******";
var wrongPassword = "******";
AddUser(username, password);
var url = GetReplicationURLWithoutCredentials();
var httpClientFactory = new CouchbaseLiteHttpClientFactory(new CookieStore());
manager.DefaultHttpClientFactory = httpClientFactory;
var replicator = database.CreatePushReplication(url);
replicator.Authenticator = AuthenticatorFactory.CreateBasicAuthenticator(username, wrongPassword);
Assert.IsNotNull(replicator);
Assert.IsNotNull(replicator.Authenticator);
Assert.IsTrue(replicator.Authenticator is BasicAuthenticator);
replicator.Start();
var doneEvent = new ManualResetEvent(false);
Task.Factory.StartNew(() =>
{
var timeout = DateTime.UtcNow + TimeSpan.FromSeconds(30);
var stop = false;
while (DateTime.UtcNow < timeout && !stop)
{
stop |= replicator.Status != ReplicationStatus.Active;
Sleep(TimeSpan.FromMilliseconds(10));
}
doneEvent.Set();
});
doneEvent.WaitOne(TimeSpan.FromSeconds(10));
Sleep(1000);
var lastError = replicator.LastError;
Assert.IsNotNull(lastError);
}
