public void TestScriptContext()
{
ScriptContextBuilder builder = new ScriptContextBuilder();
builder.ScriptLanguage = ("language");
builder.ScriptText = ("text");
builder.AddScriptArgument("foo", "bar");
builder.AddScriptArgument("foo2", "bar2");
ScriptContext v1 = builder.Build();
ScriptContext v2 = (ScriptContext)CloneObject(v1);
Assert.AreEqual(2, v2.ScriptArguments.Count);
Assert.AreEqual("bar", v2.ScriptArguments["foo"]);
Assert.AreEqual("bar2", v2.ScriptArguments["foo2"]);
Assert.AreEqual("language", v2.ScriptLanguage);
Assert.AreEqual("text", v2.ScriptText);
}
public void TestScriptOnConnectorWithCache()
{
var builder = new ScriptContextBuilder();
builder.ScriptLanguage = "POWERShell";
builder.ScriptText = "$Connector.Configuration.PropertyBag['cache'] = $Connector.Arguments.uid.GetUidValue()";
var uid = new Uid("foo", "12345");
builder.AddScriptArgument("uid", uid);
GetFacade().RunScriptOnConnector(builder.Build(), null);
builder.ScriptText = "return $Connector.Configuration.PropertyBag['cache']";
var res = GetFacade().RunScriptOnConnector(builder.Build(), null) as List<object>;
if (res != null)
{
Assert.AreEqual(res[0], uid.GetUidValue());
}
else
{
throw new ConnectorException("Not the expected result");
}
}
public void TestScriptOnConnector()
{
var builder = new ScriptContextBuilder();
builder.ScriptLanguage = "POWERShell";
builder.ScriptText = "Write-Warning \"Test\"; return $Connector.Arguments.uid.GetUidValue()";
var uid = new Uid("foo", "12345");
builder.AddScriptArgument("uid", uid);
var res = GetFacade().RunScriptOnConnector(builder.Build(), null) as Collection<object>;
if (res != null)
{
Assert.AreEqual(res[0], uid.GetUidValue());
}
}
public void TestScriptOnConnectorParalell()
{
Action<String, int> timeStamp = (prefix, test) =>
{
Console.WriteLine("{0}:{1} = {2}", prefix, test, DateTime.Now.ToString("O"));
};
var builder = new ScriptContextBuilder();
builder.ScriptLanguage = "POWERShell";
builder.ScriptText = "Start-Sleep -s 15; return Get-Date -Format o";
var longRunningContext = builder.Build();
builder.ScriptText = "Start-Sleep -s 10; return Get-Date -Format o";
var mediumRunningContext = builder.Build();
builder.ScriptText = "Start-Sleep -s 5; return Get-Date -Format o";
var shortRunningContext = builder.Build();
string[] result = new string[5];
var facade = GetFacade();
Parallel.ForEach(
new[]
{
Pair<int, ScriptContext>.Of(0, longRunningContext),
Pair<int, ScriptContext>.Of(1, mediumRunningContext),
Pair<int, ScriptContext>.Of(2, shortRunningContext),
Pair<int, ScriptContext>.Of(3, mediumRunningContext),
Pair<int, ScriptContext>.Of(4, shortRunningContext)
},
new ParallelOptions() {MaxDegreeOfParallelism = 5},
(context, options) =>
{
timeStamp("Start", context.First);
var res = facade.RunScriptOnConnector(context.Second, null);
timeStamp("End ", context.First);
var collection = res as List<object>;
if (collection != null)
result[context.First] = collection[0] as String;
});
Assert.Greater(result[0], result[1]);
Assert.Greater(result[0], result[2]);
Assert.Less(result[2], result[1]);
}
public void TestScriptOperations()
{
IAsyncConnectorInfoManager manager = ConnectorInfoManager;
var task = manager.FindConnectorInfoAsync(TestStatefulConnectorKey);
Assert.IsTrue(task.Wait(TimeSpan.FromMinutes(5)));
ConnectorFacade facade = ConnectorFacade;
ScriptContextBuilder contextBuilder = new ScriptContextBuilder
{
ScriptLanguage = "Boo",
ScriptText = "arg",
};
contextBuilder.AddScriptArgument("arg", "test");
object o = facade.RunScriptOnConnector(contextBuilder.Build(), null);
Assert.AreEqual(o, "test");
o = facade.RunScriptOnResource(contextBuilder.Build(), null);
Assert.AreEqual(o, "test");
}
public void TestNullOperations()
{
IAsyncConnectorInfoManager manager = ConnectorInfoManager;
var task = manager.FindConnectorInfoAsync(TestStatefulConnectorKey);
Assert.IsTrue(task.Wait(TimeSpan.FromMinutes(5)));
ConnectorFacade facade = GetConnectorFacade(true, true);
OperationOptionsBuilder optionsBuilder = new OperationOptionsBuilder();
facade.Test();
Assert.IsNull(facade.Schema());
var guardedString = new GuardedString();
"Passw0rd".ToCharArray().ToList().ForEach(p => guardedString.AppendChar(p));
Uid uid = facade.Create(ObjectClass.ACCOUNT,
CollectionUtil.NewSet(new Name("CREATE_01"), ConnectorAttributeBuilder.BuildPassword(guardedString)),
optionsBuilder.Build());
Assert.IsNull(uid);
Uid resolvedUid = facade.ResolveUsername(ObjectClass.ACCOUNT, "CREATE_01", optionsBuilder.Build());
Assert.IsNull(resolvedUid);
Uid authenticatedUid = facade.Authenticate(ObjectClass.ACCOUNT, "CREATE_01", guardedString,
optionsBuilder.Build());
Assert.IsNull(authenticatedUid);
SyncToken token = facade.GetLatestSyncToken(ObjectClass.ACCOUNT);
Assert.IsNull(token);
SyncToken lastToken = facade.Sync(ObjectClass.ACCOUNT, new SyncToken(-1),
new SyncResultsHandler {Handle = delta => true}, optionsBuilder.Build());
Assert.IsNull(lastToken);
SearchResult searchResult = facade.Search(ObjectClass.ACCOUNT, null,
new ResultsHandler {Handle = connectorObject => true}, optionsBuilder.Build());
Assert.IsNull(searchResult);
Uid updatedUid = facade.Update(ObjectClass.ACCOUNT, new Uid("1"),
CollectionUtil.NewSet(ConnectorAttributeBuilder.BuildLockOut(true)), optionsBuilder.Build());
Assert.IsNull(updatedUid);
ConnectorObject co = facade.GetObject(ObjectClass.ACCOUNT, new Uid("1"), optionsBuilder.Build());
Assert.IsNull(co);
ScriptContextBuilder contextBuilder = new ScriptContextBuilder
{
ScriptLanguage = "Boo",
ScriptText = "arg"
};
contextBuilder.AddScriptArgument("arg", "test");
object o = facade.RunScriptOnConnector(contextBuilder.Build(), optionsBuilder.Build());
Assert.AreEqual(o, "test");
o = facade.RunScriptOnResource(contextBuilder.Build(), optionsBuilder.Build());
Assert.IsNull(o);
}
public virtual void TestConfigurationUpdate()
{
IAsyncConnectorInfoManager manager = ConnectorInfoManager;
var taskA = manager.FindConnectorInfoAsync(TestStatefulConnectorKey);
var taskB = manager.FindConnectorInfoAsync(TestPoolableStatefulConnectorKey);
Assert.IsTrue(taskA.Wait(TimeSpan.FromMinutes(5)));
Assert.IsTrue(taskB.Wait(TimeSpan.FromMinutes(5)));
ConnectorInfo[] infos =
{
taskA.Result,
taskB.Result
};
foreach (ConnectorInfo info in infos)
{
APIConfiguration api = info.CreateDefaultAPIConfiguration();
ConfigurationProperties props = api.ConfigurationProperties;
props.GetProperty("randomString").Value = StringUtil.RandomString();
api.ProducerBufferSize = 0;
var listener = new ConfigurationPropertyChangeListener();
api.ChangeListener = listener;
ConnectorFacade facade = ConnectorFramework.NewInstance(api);
ScriptContextBuilder builder = new ScriptContextBuilder
{
ScriptLanguage = "Boo",
ScriptText = "connector.Update()"
};
facade.RunScriptOnConnector(builder.Build(), null);
for (int i = 0; (i < 25 && null == listener.Changes); i++)
{
Thread.Sleep(1000);
}
Assert.NotNull(listener.Changes);
Assert.AreEqual(listener.Changes.Count, 1);
Assert.AreEqual(listener.Changes.First().Value, "change");
}
}
public void TestScripting()
{
ConnectorInfoManager manager =
GetConnectorInfoManager();
ConnectorInfo info =
FindConnectorInfo(manager,
"1.0.0.0",
"org.identityconnectors.testconnector.TstConnector");
Assert.IsNotNull(info);
APIConfiguration api = info.CreateDefaultAPIConfiguration();
ConnectorFacadeFactory facf = ConnectorFacadeFactory.GetInstance();
ConnectorFacade facade = facf.NewInstance(api);
ScriptContextBuilder builder = new ScriptContextBuilder();
builder.AddScriptArgument("arg1", "value1");
builder.AddScriptArgument("arg2", "value2");
builder.ScriptLanguage = ("BOO");
//test that they can run the script and access the
//connector object
{
String SCRIPT =
"connector.concat(arg1,arg2)";
builder.ScriptText = (SCRIPT);
String result = (String)facade.RunScriptOnConnector(builder.Build(),
null);
Assert.AreEqual("value1value2", result);
}
//test that they can access a class in the class loader
{
String SCRIPT =
"import org.identityconnectors.testconnector\n" +
"TstConnector.GetVersion()";
builder.ScriptText = (SCRIPT);
String result = (String)facade.RunScriptOnConnector(builder.Build(),
null);
Assert.AreEqual("1.0", result);
}
//test that they cannot access a class in internal
{
Type clazz = typeof(ConfigurationPropertyImpl);
String SCRIPT =
"import " + clazz.Namespace + "\n" +
clazz.Name + "()";
builder.ScriptText = (SCRIPT);
try
{
facade.RunScriptOnConnector(builder.Build(),
null);
Assert.Fail("exception expected");
}
catch (Exception e)
{
String msg = e.Message;
String expectedMessage =
"Namespace '" + clazz.Namespace + "' not found";
Assert.IsTrue(
msg.Contains(expectedMessage),
"Unexpected message: " + msg);
}
}
// test that they can access a class in common
{
Type clazz = typeof(ConnectorAttributeBuilder);
String SCRIPT =
"import " + clazz.Namespace + "\n" +
clazz.Name + ".Build(\"myattr\")";
builder.ScriptText = (SCRIPT);
ConnectorAttribute attr = (ConnectorAttribute)facade.RunScriptOnConnector(builder.Build(), null);
Assert.AreEqual("myattr", attr.Name);
}
}
