public async Task Run_for_a_while_using_WebSocket()
{
// Begin: README example
var bayeuxClient = new BayeuxClient(
new WebSocketTransportOptions()
{
Uri = new Uri("ws://localhost:8080/bayeux/"),
});
// End: README example
bayeuxClient.EventReceived += (e, args) =>
Debug.WriteLine($"Event received on channel {args.Channel} with data\n{args.Data}");
bayeuxClient.ConnectionStateChanged += (e, args) =>
Debug.WriteLine($"Bayeux connection state changed to {args.ConnectionState}");
bayeuxClient.AddSubscriptions("/**");
await bayeuxClient.Start();
using (bayeuxClient)
{
await Delay(60);
}
}
public async Task Reconnections()
{
var mock = new Mock <HttpMessageHandler>();
mock.Protected().As <IHttpMessageHandlerProtected>()
.SetupSequence(h => h.SendAsync(It.IsAny <HttpRequestMessage>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(BuildBayeuxResponse(successfulHandshakeResponse))
.ReturnsAsync(BuildBayeuxResponse(successfulConnectResponse))
.ReturnsAsync(BuildBayeuxResponse(rehandshakeConnectResponse))
.ThrowsAsync(new HttpRequestException("mock raising exception"))
.ReturnsAsync(BuildBayeuxResponse(successfulHandshakeResponse))
.ThrowsAsync(new HttpRequestException("mock raising exception"))
.ThrowsAsync(new HttpRequestException("mock raising exception"))
.ThrowsAsync(new HttpRequestException("mock raising exception"))
.ThrowsAsync(new HttpRequestException("mock raising exception"))
.ThrowsAsync(new HttpRequestException("mock raising exception"))
.ReturnsIndefinitely(() =>
Task.Delay(TimeSpan.FromSeconds(5))
.ContinueWith(t => BuildBayeuxResponse(successfulHandshakeResponse)))
;
var bayeuxClient = new BayeuxClient(
new HttpLongPollingTransportOptions()
{
HttpClient = new HttpClient(mock.Object), Uri = Url
},
reconnectDelays: new[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) });
using (bayeuxClient)
{
await bayeuxClient.Start();
await Task.Delay(TimeSpan.FromSeconds(20));
}
}
public async Task Run_for_a_while_using_HTTP()
{
// Begin: README example
var httpClient = new HttpClient();
var bayeuxClient = new BayeuxClient(
new HttpLongPollingTransportOptions()
{
HttpClient = httpClient,
Uri = "http://localhost:8080/bayeux/",
});
bayeuxClient.EventReceived += (e, args) =>
Debug.WriteLine($"Event received on channel {args.Channel} with data\n{args.Data}");
bayeuxClient.ConnectionStateChanged += (e, args) =>
Debug.WriteLine($"Bayeux connection state changed to {args.ConnectionState}");
bayeuxClient.AddSubscriptions("/**");
await bayeuxClient.Start();
// End: README example
using (bayeuxClient)
{
await Delay(60);
}
}
public async Task Too_long_connect_delay_causes_unauthorized_error_in_Workspace_API()
{
var httpPost =
new AgentApiHttpPoster(
new HttpClientHttpPost(await InitHttpClient()),
BaseUrl);
//var initResponse = await httpClient.PostAsync(
// BaseURL + "/workspace/v3/initialize-workspace",
// new StringContent(""));
//initResponse.EnsureSuccessStatusCode();
var bayeuxClient = new BayeuxClient(new HttpLongPollingTransportOptions()
{
HttpPost = httpPost,
Uri = BaseUrl + "/workspace/v3/notifications",
});
using (bayeuxClient)
{
await bayeuxClient.Start();
await bayeuxClient.Subscribe("/**");
Thread.Sleep(TimeSpan.FromSeconds(11));
}
}
// response: {"timestamp":1536851691737,"status":500,"error":"Internal Server Error",
// "message":"java.lang.IllegalArgumentException: Invalid channel id: pepe",
// "path":"/statistics/v3/notifications"}
public async Task Subscribe_invalid_channel_id()
{
var httpClient = await InitHttpClient();
var bayeuxClient = new BayeuxClient(new HttpLongPollingTransportOptions()
{
HttpClient = httpClient,
Uri = BaseUrl + "/statistics/v3/notifications",
});
await bayeuxClient.Start();
await bayeuxClient.Subscribe("pepe");
}
private static async Task <BayeuxClient> SubToStream(String uri, String channel)
{
var httpClient = new HttpClient();
var bayeuxClient = new BayeuxClient(
new HttpLongPollingTransportOptions()
{
HttpClient = httpClient,
Uri = uri
});
bayeuxClient.ConnectionStateChanged += (e, args) =>
Console.WriteLine($"Bayeux connection state changed to {args.ConnectionState}");
bayeuxClient.AddSubscriptions(channel);
await bayeuxClient.Start();
return(bayeuxClient);
}
public async Task Automatic_subscription()
{
var mock = new Mock <HttpMessageHandler>();
var mockProtected = mock.Protected().As <IHttpMessageHandlerProtected>();
int subscriptionCount = 0;
mockProtected
.Setup(h => h.SendAsync(MatchSubscriptionRequest(), It.IsAny <CancellationToken>()))
.Returns(() =>
Task.Run(() => subscriptionCount++)
.ContinueWith(t => BuildBayeuxResponse(successfulSubscriptionResponse)));
mockProtected
.Setup(h => h.SendAsync(MatchHandshakeRequest(), It.IsAny <CancellationToken>()))
.ReturnsAsync(BuildBayeuxResponse(successfulHandshakeResponse));
mockProtected
.Setup(h => h.SendAsync(MatchConnectRequest(), It.IsAny <CancellationToken>()))
.Returns(() =>
Task.Delay(TimeSpan.FromSeconds(5))
.ContinueWith(t => BuildBayeuxResponse(successfulConnectResponse)));
var bayeuxClient = new BayeuxClient(
new HttpLongPollingTransportOptions()
{
HttpClient = new HttpClient(mock.Object), Uri = Url
},
reconnectDelays: new[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) });
using (bayeuxClient)
{
bayeuxClient.AddSubscriptions("/mychannel");
await bayeuxClient.Start();
await Task.Delay(TimeSpan.FromSeconds(2));
}
Assert.AreEqual(1, subscriptionCount);
}
protected override async Task StartImplAsync(UpdateResult result, CancellationToken cancellationToken)
{
httpClient.DefaultRequestHeaders.Remove("x-api-key");
httpClient.DefaultRequestHeaders.Add("x-api-key", ApiKey);
var token = await AuthApi.Authenticate(httpClient, ApiBaseUrl, new AuthApi.PasswordGrantTypeCredentials()
{
ClientId = ClientId,
ClientSecret = ClientSecret,
UserName = UserName,
Password = Password,
}); // TODO: missing cancellationToken as a parameter here
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var initResponse = await PostAsync("/workspace/v3/initialize-workspace", null, cancellationToken);
bayeuxClient = new BayeuxClient(new HttpLongPollingTransportOptions()
{
HttpClient = httpClient,
Uri = ApiBaseUrl + "/workspace/v3/notifications"
});
bayeuxClient.EventReceived += (e, args) =>
{
Debug.WriteLine($"Event received on channel {args.Channel} with data\n{args.Data}");
UpdateTree(result2 =>
result2.MessageToChildren = args);
};
bayeuxClient.ConnectionStateChanged += (e, args) =>
Debug.WriteLine($"Bayeux connection state changed to {args.ConnectionState}");
await bayeuxClient.Start(cancellationToken);
await bayeuxClient.Subscribe("/**", cancellationToken);
}
public void Provisioning_API__Awaiting_dbUpdated_event()
{
#region Obtain token
object baseUrl = TestContext.Properties["BaseUrl"];
var authApi = new AuthenticationApi(
new Genesys.Internal.Authentication.Client.Configuration
{
BasePath = baseUrl + "/auth/v3",
DefaultHeader = new Dictionary <string, string>()
{
["x-api-key"] = (string)TestContext.Properties["ApiKey"],
},
});
var clientId = (string)TestContext.Properties["ClientId"];
var clientSecret = (string)TestContext.Properties["ClientSecret"];
var tenant = (string)TestContext.Properties["UserNamePath"];
var userName = (string)TestContext.Properties["UserName"];
var userPassword = (string)TestContext.Properties["Password"];
var tokenResponse = authApi.RetrieveToken(
grantType: "password",
authorization:
"Basic " +
Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(
clientId + ":" + clientSecret)),
username: tenant == null ? userName : tenant + "\\" + userName,
clientId: clientId,
password: userPassword);
Debug.WriteLine("Access token obtained: " + tokenResponse.AccessToken);
#endregion
#region Initialize Provisioning API, cookies, and notifications
Debug.WriteLine("Initializing Provisioning API...");
var provisioningBaseUrl = (string)TestContext.Properties["ProvisioningBaseUrl"];
var apiKey = (string)TestContext.Properties["ApiKey"];
var provisioningApiConfig = new Genesys.Internal.Provisioning.Client.Configuration
{
BasePath = provisioningBaseUrl + "/provisioning/v3",
DefaultHeader = new Dictionary <string, string>()
{
["x-api-key"] = apiKey,
["Authorization"] = "Bearer " + tokenResponse.AccessToken,
},
};
var cookieContainer = new System.Net.CookieContainer();
provisioningApiConfig.ApiClient.RestClient.CookieContainer = cookieContainer;
var sessionApi = new SessionApi(provisioningApiConfig);
var initResponse = sessionApi.InitializeProvisioning();
Debug.WriteLine("Provisioning API initialized: " + initResponse);
Debug.WriteLine("Starting notifications...");
var bayeuxClient = new BayeuxClient(new HttpLongPollingTransportOptions
{
HttpClient = new HttpClient(new HttpClientHandler {
CookieContainer = cookieContainer
}),
Uri = provisioningBaseUrl + "/provisioning/v3/notifications",
});
bayeuxClient.EventReceived += (e, eventArgs) =>
//Debug.WriteLine($"Event received on channel {eventArgs.Channel} with data\n{eventArgs.Data}\nFull message:\n{eventArgs.Message}");
Debug.WriteLine($"Event received:\n{eventArgs.Message}");
bayeuxClient.ConnectionStateChanged += (e, eventArgs) =>
Debug.WriteLine($"Bayeux connection state changed to {eventArgs.ConnectionState}");
bayeuxClient.AddSubscriptions("/**");
bayeuxClient.Start().Wait();
Debug.WriteLine("Notifications started.");
#endregion
var provisioningApiLoaded = new ManualResetEventSlim();
EventHandler <EventReceivedArgs> dbUpdatedHandler = (_, e) =>
{
bool?dbUpdated = e.Data["data"]?["dbUpdated"]?.ToObject <bool>();
if (dbUpdated.GetValueOrDefault(false))
{
provisioningApiLoaded.Set();
}
};
bayeuxClient.EventReceived += dbUpdatedHandler;
#region Trigger cache load
Debug.WriteLine("Calling /args...");
IRestResponse argsResponse = (IRestResponse)provisioningApiConfig.ApiClient.CallApi(
method: Method.GET,
path: "/args",
queryParams: new List <KeyValuePair <String, String> >(),
postBody: null,
headerParams: new Dictionary <String, String>(provisioningApiConfig.DefaultHeader)
{
{ "Accept", "application/json" },
},
formParams: new Dictionary <String, String>(),
fileParams: new Dictionary <String, FileParameter>(),
pathParams: new Dictionary <String, String>(),
contentType: provisioningApiConfig.ApiClient.SelectHeaderContentType(new String[] { "application/json" }));
Debug.WriteLine("/args called: " + argsResponse);
int localVarStatusCode = (int)argsResponse.StatusCode;
var exception = Genesys.Internal.Provisioning.Client.Configuration.DefaultExceptionFactory?.Invoke("GetArgs", argsResponse);
if (exception != null)
{
throw exception;
}
#endregion
Debug.WriteLine("Waiting for dbUpdated...");
provisioningApiLoaded.Wait(timeout: TimeSpan.FromSeconds(5));
bayeuxClient.EventReceived -= dbUpdatedHandler;
Debug.WriteLine("dbUpdated received.");
//Debug.WriteLine("Sleeping...");
//Thread.Sleep(TimeSpan.FromSeconds(0));
//Debug.WriteLine("Finished sleep.");
#region Call GET users
var usersApi = new UsersApi(provisioningApiConfig);
Debug.WriteLine("GETting users...");
var usersResponse = usersApi.GetUsers(
//limit: 1,
//offset: 0,
filterName: "FirstNameOrLastNameMatches",
filterParameters: "*****@*****.**"
//filterParameters: "*****@*****.**",
//filterParameters: "*****@*****.**",
//userEnabled: false
);
var firstUser = (Newtonsoft.Json.Linq.JObject)usersResponse.Data.Users.FirstOrDefault();
Debug.WriteLine("User found: {0}", firstUser.ToString() ?? "none");
#endregion
}
