public void Consumer_AuthorizeUser()
{
//arrange
var provider = A.Fake<IOAuthProvider>();
IConsumer consumer = new ConsumerFactory(options, provider)
.CreateConsumer();
var request_token = "requestToken";
var request_token_secret = "requestTokenSecret";
var authorize_url = new Uri("http://expectedUrl");
var verifier = "verifier";
var getRequestTokenRequestResult = string.Format("oauth_token={0}&oauth_token_secret={1}&oauth_expires_in=124&xoauth_request_auth_url={2}",
request_token,
request_token_secret,
authorize_url);
var access_token = "accessToken";
var access_token_secret = "accessTokenSecret";
var tokenInfo = new TokenInfo
{
AccessToken = access_token,
AccessTokenSecret = access_token_secret,
};
var getAccessTokenRequestResult = string.Format("oauth_token={0}&oauth_token_secret={1}&oauth_expires_in=124&oauth_session_handle=12334&oauth_authorization_expires_in=1234",
access_token,
access_token_secret);
A.CallTo(() => provider.GetRequestTokenRequest(
A<string>._, A<string>._, A<string>._, A<string>._, A<SignatureMethod>._))
.Returns(getRequestTokenRequestResult);
A.CallTo(() => provider.GetGetAccessTokenRequest(
A<string>._, A<string>._, A<string>._, A<string>._, A<SignatureMethod>._, A<string>._, A<string>._))
.Returns(getAccessTokenRequestResult);
//act
consumer.RequestLogin();
var actualTokenInfo = consumer.AuthorizeUser(verifier);
//assert
A.CallTo(() => provider.GetRequestTokenRequest(
options.RequestTokenUrl,
options.ConsumerKey,
options.ConsumerSecret,
options.RequestTokenResponseCallbackUrl,
options.SignatureMethod));
A.CallTo(() => provider.GetGetAccessTokenRequest(
options.AccessTokenUrl,
options.ConsumerKey,
options.ConsumerSecret,
request_token_secret,
options.SignatureMethod,
request_token,
verifier));
Assert.AreEqual(tokenInfo.AccessToken, actualTokenInfo.AccessToken);
Assert.AreEqual(tokenInfo.AccessTokenSecret, actualTokenInfo.AccessTokenSecret);
}
public void ConsumerFactory_CanCreateConsumer()
{
IConsumerFactory factory = new ConsumerFactory(options);
IConsumer consumer = factory.CreateConsumer();
Assert.IsNotNull(consumer);
Assert.AreEqual(factory.ConsumerOptions, consumer.ConsumerOptions);
}
public void Consumer_CanAuthorizeUserAsync()
{
//arrange
options.RequestTokenResponseCallbackUrl = TU.GenerateLocalHostBaseAddress();
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
string verifier = null;
var lisnrManualResetEvent = new ManualResetEvent(false);
var requestLoginManualEvent = new ManualResetEvent(false);
var authorizeUserManualEvent = new ManualResetEvent(false);
Task<Uri> task = consumer.RequestLoginAsync();
task.ContinueWith(uri => requestLoginManualEvent.Set());
requestLoginManualEvent.WaitOne();
Process.Start(task.Result.ToString());
var listener = new HttpListener();
listener.Prefixes.Add(options.RequestTokenResponseCallbackUrl);
listener.Start();
listener.BeginGetContext(
((r) =>
{
var lisnr = (HttpListener)r.AsyncState;
var context = lisnr.EndGetContext(r);
var rq = context.Request.GetRequestParameters();
verifier = rq.Where(p => p.Name == "oauth_verifier")
.Select(p => p.Value)
.First();
lisnrManualResetEvent.Set();
}),
listener);
lisnrManualResetEvent.WaitOne();
((IDisposable)listener).Dispose();
//act
//assert
Task<TokenInfo> authorizeUserTask = consumer.AuthorizeUserAsync(verifier);
task.ContinueWith(token => authorizeUserManualEvent.Set());
authorizeUserManualEvent.WaitOne();
//assert
Assert.IsFalse(authorizeUserTask.IsFaulted);
Assert.IsNull(authorizeUserTask.Exception);
Assert.IsNotNull(authorizeUserTask.Result);
}
public void Conumser_CanGetUserFantasySports_Information()
{
//arrange
options.RequestTokenResponseCallbackUrl = TU.GenerateLocalHostBaseAddress();
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
string verifier = null;
var uri = consumer.RequestLogin();
Process.Start(uri.ToString());
var listener = new HttpListener();
listener.Prefixes.Add(options.RequestTokenResponseCallbackUrl);
listener.Start();
var manualResetEvent = new ManualResetEvent(false);
listener.BeginGetContext(
((r) =>
{
var lisnr = (HttpListener)r.AsyncState;
var context = lisnr.EndGetContext(r);
var rq = context.Request.GetRequestParameters();
verifier = rq.Where(p => p.Name == "oauth_verifier")
.Select(p => p.Value)
.First();
manualResetEvent.Set();
}),
listener);
manualResetEvent.WaitOne();
((IDisposable)listener).Dispose();
var accessToken = consumer.AuthorizeUser(verifier);
//act
var request = consumer.CreateHttpRequest("http://fantasysports.yahooapis.com/fantasy/v2/users;use_login=1/games", HttpMethod.GET);
using (var response = request.GetResponse() as HttpWebResponse)
{
Assert.IsNotNull(response);
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
}
}
public static IDisposable Subscribe <T>(
this IRillConsumable <T> consumable,
NewEventHandler <T> onNew,
SuccessfulEventHandler?onAllSucceeded = null,
FailedEventHandler?onAnyFailed = null)
=> consumable.Subscribe(ConsumerFactory.SynchronousConsumer(onNew, onAllSucceeded, onAnyFailed));
public void Consumer_CanRequestLoginAsync()
{
//arrange
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
var manualResetEvent = new ManualResetEvent(false);
//act
Task<Uri> task = consumer.RequestLoginAsync();
task.ContinueWith(uri => manualResetEvent.Set());
manualResetEvent.WaitOne();
//assert
Assert.IsFalse(task.IsFaulted);
Assert.IsNull(task.Exception);
Assert.IsNotNull(task.Result);
}
public void Conumser_CanAuthorizeUser()
{
//arrange
options.RequestTokenResponseCallbackUrl = TU.GenerateLocalHostBaseAddress();
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
string verifier = null;
var uri = consumer.RequestLogin();
Process.Start(uri.ToString());
var listener = new HttpListener();
listener.Prefixes.Add(options.RequestTokenResponseCallbackUrl);
listener.Start();
var manualResetEvent = new ManualResetEvent(false);
listener.BeginGetContext(
((r) =>
{
var lisnr = (HttpListener)r.AsyncState;
var context = lisnr.EndGetContext(r);
var rq = context.Request.GetRequestParameters();
verifier = rq.Where(p => p.Name == "oauth_verifier")
.Select(p => p.Value)
.First();
manualResetEvent.Set();
}),
listener);
manualResetEvent.WaitOne();
((IDisposable)listener).Dispose();
//act
//assert
Assert.IsNotNull(consumer.AuthorizeUser(verifier)); //Access Token
}
public WordpressToken(IOptionsMonitor <ILog> optionsMonitor, TokenHelper tokenHelper, ConsumerFactory consumerFactory)
{
Log = optionsMonitor.CurrentValue;
TokenHelper = tokenHelper;
ConsumerFactory = consumerFactory;
}
public OAuth20TokenHelper(IHttpContextAccessor httpContextAccessor, ConsumerFactory consumerFactory)
{
HttpContextAccessor = httpContextAccessor;
ConsumerFactory = consumerFactory;
}
public void ConsumerFactory_CanInitializeConsumerFactory()
{
IConsumerFactory factory = new ConsumerFactory(options);
Assert.AreEqual(options, factory.ConsumerOptions);
}
public void Consumer_CanRequestLogin_InvalidUrlReturned_ThrowsException()
{
//arrange
var provider = A.Fake<IOAuthProvider>();
IConsumer consumer = new ConsumerFactory(options, provider)
.CreateConsumer();
var expectedUrl = "expectedUrl";
var result = string.Format("oauth_token=1234&oauth_token_secret=1234&oauth_expires_in=124&xoauth_request_auth_url={0}", expectedUrl);
A.CallTo(() => provider.GetRequestTokenRequest(
A<string>._, A<string>._, A<string>._, A<string>._, A<SignatureMethod>._))
.Returns(result);
try
{
//act
var actualUrl = consumer.RequestLogin();
}
catch (UriFormatException)
{
//assert
A.CallTo(() => provider.GetRequestTokenRequest(
options.RequestTokenUrl,
options.ConsumerKey,
options.ConsumerSecret,
options.RequestTokenResponseCallbackUrl,
options.SignatureMethod));
return;
}
Assert.Fail("UriFormatException expected");
}
public OneDriveStorage(ConsumerFactory consumerFactory)
{
ConsumerFactory = consumerFactory;
}
public void Consumer_CannotRequestLoginAsync_InvalidConsumerKey_TaskFaultedWithException()
{
//arrange
options.ConsumerKey = "InvalidConsumerKey";
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
try
{
//act
Task<Uri> task = consumer.RequestLoginAsync();
task.Wait();
}
catch (AggregateException ex)
{
//assert
Assert.IsNotNull(ex.InnerException);
Assert.IsInstanceOfType(ex.InnerException, typeof(CommunicationException));
}
}
/// <summary>
/// </summary>
/// <param name="context"></param>
/// <param name="fileStorageService"></param>
public FilesControllerHelper(
ApiContext context,
FileStorageService <T> fileStorageService,
GlobalFolderHelper globalFolderHelper,
FileWrapperHelper fileWrapperHelper,
FilesSettingsHelper filesSettingsHelper,
FilesLinkUtility filesLinkUtility,
FileUploader fileUploader,
DocumentServiceHelper documentServiceHelper,
TenantManager tenantManager,
SecurityContext securityContext,
FolderWrapperHelper folderWrapperHelper,
FileOperationWraperHelper fileOperationWraperHelper,
FileShareWrapperHelper fileShareWrapperHelper,
FileShareParamsHelper fileShareParamsHelper,
EntryManager entryManager,
UserManager userManager,
WebItemSecurity webItemSecurity,
CoreBaseSettings coreBaseSettings,
ThirdpartyConfiguration thirdpartyConfiguration,
MessageService messageService,
CommonLinkUtility commonLinkUtility,
DocumentServiceConnector documentServiceConnector,
FolderContentWrapperHelper folderContentWrapperHelper,
WordpressToken wordpressToken,
WordpressHelper wordpressHelper,
ConsumerFactory consumerFactory,
EasyBibHelper easyBibHelper,
ChunkedUploadSessionHelper chunkedUploadSessionHelper,
ProductEntryPoint productEntryPoint)
{
ApiContext = context;
FileStorageService = fileStorageService;
GlobalFolderHelper = globalFolderHelper;
FileWrapperHelper = fileWrapperHelper;
FilesSettingsHelper = filesSettingsHelper;
FilesLinkUtility = filesLinkUtility;
FileUploader = fileUploader;
DocumentServiceHelper = documentServiceHelper;
TenantManager = tenantManager;
SecurityContext = securityContext;
FolderWrapperHelper = folderWrapperHelper;
FileOperationWraperHelper = fileOperationWraperHelper;
FileShareWrapperHelper = fileShareWrapperHelper;
FileShareParamsHelper = fileShareParamsHelper;
EntryManager = entryManager;
UserManager = userManager;
WebItemSecurity = webItemSecurity;
CoreBaseSettings = coreBaseSettings;
ThirdpartyConfiguration = thirdpartyConfiguration;
ConsumerFactory = consumerFactory;
BoxLoginProvider = ConsumerFactory.Get <BoxLoginProvider>();
DropboxLoginProvider = ConsumerFactory.Get <DropboxLoginProvider>();
GoogleLoginProvider = ConsumerFactory.Get <GoogleLoginProvider>();
OneDriveLoginProvider = ConsumerFactory.Get <OneDriveLoginProvider>();
MessageService = messageService;
CommonLinkUtility = commonLinkUtility;
DocumentServiceConnector = documentServiceConnector;
FolderContentWrapperHelper = folderContentWrapperHelper;
WordpressToken = wordpressToken;
WordpressHelper = wordpressHelper;
EasyBibHelper = easyBibHelper;
ChunkedUploadSessionHelper = chunkedUploadSessionHelper;
ProductEntryPoint = productEntryPoint;
}
public ScopeTelegramLauncher(TenantManager tenantManager, TelegramHandler telegramHandler, ConsumerFactory consumerFactory)
{
TelegramLoginProvider = consumerFactory.Get <TelegramLoginProvider>();
TenantManager = tenantManager;
Handler = telegramHandler;
}
public PluginsConfig(ConsumerFactory consumerFactory, BaseCommonLinkUtility baseCommonLinkUtility)
{
ConsumerFactory = consumerFactory;
BaseCommonLinkUtility = baseCommonLinkUtility;
}
public ProviderManager(Signature signature, InstanceCrypto instanceCrypto, ConsumerFactory consumerFactory)
{
Signature = signature;
InstanceCrypto = instanceCrypto;
ConsumerFactory = consumerFactory;
}
public Cluster(Configuration configuration, ILogger logger, NodeFactory nodeFactory, ProducerFactory producerFactory, ConsumerFactory consumerFactory, IStatistics statistics = null)
{
_configuration = configuration;
_seeds = configuration.Seeds;
Logger = logger;
Statistics = statistics ?? new Statistics();
_timeoutScheduler = new TimeoutScheduler(configuration.ClientRequestTimeoutMs / 2);
_pools = InitPools(Statistics, configuration);
// Producer init
ProduceRouter = producerFactory != null?producerFactory() : new ProduceRouter(this, configuration, _pools.MessageBuffersPool);
ProduceRouter.MessageExpired += (t, m) =>
{
Statistics.UpdateExpired();
UpdateExited(1);
};
ProduceRouter.MessagesAcknowledged += (t, c) =>
{
Statistics.UpdateSuccessfulSent(c);
UpdateExited(c);
SignalSeenTopic(t);
};
ProduceRouter.MessageDiscarded += (t, m) =>
{
Statistics.UpdateDiscarded();
UpdateExited(1);
};
RoutingTableChange += ProduceRouter.ChangeRoutingTable;
ProduceRouter.BrokerTimeoutError += Statistics.UpdateBrokerTimeoutError;
ProduceRouter.MessageReEnqueued += Statistics.UpdateMessageRetry;
ProduceRouter.MessagePostponed += Statistics.UpdateMessagePostponed;
// Consumer init
ConsumeRouter = consumerFactory != null?consumerFactory() : new ConsumeRouter(this, configuration);
ConsumeRouter.MessageReceived += _ => Statistics.UpdateReceived();
if (ConsumeRouter is ConsumeRouter)
{
(ConsumeRouter as ConsumeRouter).InternalError +=
ex => Logger.LogError("An unexpected error occured in the consumer: " + ex);
}
RoutingTableChange += ConsumeRouter.ChangeRoutingTable;
// Node factory
var clientId = Encoding.UTF8.GetBytes(configuration.ClientId);
var serializer = new Node.Serialization(configuration.SerializationConfig, configuration.Compatibility, _pools.RequestsBuffersPool, clientId, configuration.RequiredAcks, configuration.RequestTimeoutMs,
configuration.CompressionCodec, configuration.FetchMinBytes, configuration.FetchMaxWaitTime);
_nodeFactory = nodeFactory ??
((h, p) =>
new Node(string.Format("[{0}:{1}]", h, p),
() =>
new Connection(h, p, ep => new RealSocket(ep), _pools.SocketBuffersPool, _pools.RequestsBuffersPool, configuration.SendBufferSize, configuration.ReceiveBufferSize),
serializer,
configuration,
_timeoutScheduler,
_resolution));
_nodeFactory = DecorateFactory(_nodeFactory);
// Inner actor
_agent = new ActionBlock <ClusterMessage>(r => ProcessMessage(r),
new ExecutionDataflowBlockOptions {
TaskScheduler = configuration.TaskScheduler
});
// Bootstrap
BuildNodesFromSeeds();
if (_nodes.Count == 0)
{
throw new ArgumentException("Invalid seeds: " + _seeds);
}
}
public static OAuth20Token RefreshToken <T>(OAuth20Token token) where T : Consumer, IOAuthProvider, new()
{
var loginProvider = ConsumerFactory.Get <T>();
return(RefreshToken(loginProvider.AccessTokenUrl, token));
}
public void Consumer_CannotRequestLoginAsync_InvalidTokenPath_TaskFaultedWithException()
{
//arrange
options.RequestTokenUrl = "http://invalid";
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
try
{
Task task = consumer.RequestLoginAsync();
task.Wait();
}
catch (AggregateException ex)
{
Assert.IsNotNull(ex.InnerException);
Assert.IsInstanceOfType(ex.InnerException, typeof(CommunicationException));
return;
}
Assert.Fail("Expected communication excepton.");
}
public void ConsumerFactory_InitializeConsumerFactor_ThrowsArgumentNullException()
{
options.AccessTokenUrl = null;
IConsumerFactory factory = new ConsumerFactory(options);
Assert.AreEqual(options, factory.ConsumerOptions);
}
public void Consumer_CannotRequestLogin_InvalidTokenPath_ThrowsException()
{
//arrange
options.RequestTokenUrl = "http://invalid";
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
try
{
Uri uri = consumer.RequestLogin();
}
catch (CommunicationException ex)
{
Assert.IsNotNull(ex.InnerException);
Assert.IsInstanceOfType(ex.InnerException, typeof(WebException));
return;
}
Assert.Fail("Expected communication excepton.");
}
public void Consumer_CreateRequest()
{
//arrange
var provider = A.Fake<IOAuthProvider>();
IConsumer consumer = new ConsumerFactory(options, provider)
.CreateConsumer();
var request_token = "requestToken";
var request_token_secret = "requestTokenSecret";
var authorize_url = new Uri("http://expectedUrl");
var verifier = "verifier";
var getRequestTokenRequestResult = string.Format("oauth_token={0}&oauth_token_secret={1}&oauth_expires_in=124&xoauth_request_auth_url={2}",
request_token,
request_token_secret,
authorize_url);
var access_token = "accessToken";
var access_token_secret = "accessTokenSecret";
var getAccessTokenRequestResult = string.Format("oauth_token={0}&oauth_token_secret={1}&oauth_expires_in=124&oauth_session_handle=12334&oauth_authorization_expires_in=1234",
access_token,
access_token_secret);
A.CallTo(() => provider.GetRequestTokenRequest(
A<string>._, A<string>._, A<string>._, A<string>._, A<SignatureMethod>._))
.Returns(getRequestTokenRequestResult);
A.CallTo(() => provider.GetGetAccessTokenRequest(
A<string>._, A<string>._, A<string>._, A<string>._, A<SignatureMethod>._, A<string>._, A<string>._))
.Returns(getAccessTokenRequestResult);
var requestParameters = new IRequestParameter[] {
new RequestParameter("test1", "value1"),
new RequestParameter("test2", "value2") };
//act
consumer.RequestLogin();
consumer.AuthorizeUser(verifier);
var request = consumer.CreateHttpRequest("http://test123", HttpMethod.GET, requestParameters);
//assert
A.CallTo(() => provider.GetRequestTokenRequest(
options.RequestTokenUrl,
options.ConsumerKey,
options.ConsumerSecret,
options.RequestTokenResponseCallbackUrl,
options.SignatureMethod));
A.CallTo(() => provider.GetGetAccessTokenRequest(
options.AccessTokenUrl,
options.ConsumerKey,
options.ConsumerSecret,
request_token_secret,
options.SignatureMethod,
request_token,
verifier));
var requestString = request.RequestUri.ToString();
var expectedSignature = OAuthMessageBuilder.GetOAuthSignature_PlainText(options.ConsumerSecret, null);
Assert.IsTrue(requestString.Contains(options.ConsumerKey), "ConsumerKey");
Assert.IsTrue(requestString.Contains("plaintext"), "SignatureMethod");
Assert.IsTrue(requestString.Contains("test1=value1"), "test1");
Assert.IsTrue(requestString.Contains("test2=value2"), "test2");
Assert.IsTrue(requestString.Contains(expectedSignature), "signature");
}
public void Consumer_CanRequestLogin()
{
//arrange
IConsumer consumer = new ConsumerFactory(options)
.CreateConsumer();
Uri uri = consumer.RequestLogin();
Assert.IsNotNull(uri);
}
public void Consumer_CanRequestLogin()
{
//arrange
var provider = A.Fake<IOAuthProvider>();
IConsumer consumer = new ConsumerFactory(options, provider)
.CreateConsumer();
var expectedUrl = new Uri("http://expectedUrl");
var result = string.Format("oauth_token=1234&oauth_token_secret=1234&oauth_expires_in=124&xoauth_request_auth_url={0}", expectedUrl);
A.CallTo(() => provider.GetRequestTokenRequest(
A<string>._, A<string>._, A<string>._, A<string>._, A<SignatureMethod>._))
.Returns(result);
//act
var actualUrl = consumer.RequestLogin();
//assert
A.CallTo(() => provider.GetRequestTokenRequest(
options.RequestTokenUrl,
options.ConsumerKey,
options.ConsumerSecret,
options.RequestTokenResponseCallbackUrl,
options.SignatureMethod));
Assert.AreEqual(expectedUrl, actualUrl);
}
public OpenIdLoginProvider(Signature signature, InstanceCrypto instanceCrypto, ConsumerFactory consumerFactory)
{
Signature = signature;
InstanceCrypto = instanceCrypto;
ConsumerFactory = consumerFactory;
}
