public void GetHubMethodFromValidHubWhenInvalidHubIsRegisteredDoesNotThrow()
{
var validHub = new HubDescriptor()
{
Name = "Valid"
};
var invalidHub = new HubDescriptor()
{
Name = "this.is.not.valid"
};
var method = new MethodDescriptor()
{
Name = "Method",
Parameters = new List <ParameterDescriptor>()
};
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IHubDescriptorProvider), () => new TestHubDescriptorProvider(validHub, invalidHub));
resolver.Register(typeof(IMethodDescriptorProvider), () => new TestMethodDescriptorProvider(validHub.Name, method));
var hubManager = new DefaultHubManager(resolver);
Assert.Same(
method,
hubManager.GetHubMethod(validHub.Name, "Method", Array.Empty <IJsonValue>()));
}
public void EnsureHubThrowsWhenCantResolve()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
Assert.Throws <InvalidOperationException>(() => hubManager.EnsureHub("__ELLO__"));
}
public HubHelper(TypeScriptGeneratorOptions options)
{
typeHelper = new TypeHelper(options);
var defaultDependencyResolver = new DefaultDependencyResolver();
hubmanager = new DefaultHubManager(defaultDependencyResolver);
}
public void GetInValidHub()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptor = hubManager.GetHub("__ELLO__");
Assert.Null(hubDescriptor);
}
public void ResolveInvalidHub()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptor = hubManager.ResolveHub("____CoreTestHub____");
Assert.Null(hubDescriptor);
}
protected override void PreStart()
{
log_.Info("SignalR hib starting...");
var hubManager = new DefaultHubManager(GlobalHost.DependencyResolver);
Hub = hubManager.ResolveHub("theHub") as TheHub;
log_.Info("SignalR hub started.");
log_.Info("SignalR actor started.");
}
public void ShouldIgnoreCaseWhenDiscoveringHubsUsingManager()
{
var resolver = new DefaultDependencyResolver();
var manager = new DefaultHubManager(resolver);
var hub = manager.GetHub("hubwithoutattribute");
Assert.NotNull(hub);
Assert.Equal(hub.Name, "HubWithoutAttribute");
}
public void ResolveHubsIsNotEmpty()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptor = hubManager.ResolveHubs();
Assert.NotNull(hubDescriptor);
Assert.NotEmpty(hubDescriptor);
}
public void GetValidHubMethodsWithPredicate()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var methodDescriptors = hubManager.GetHubMethods("CoreTestHubWithMethod", descriptor => descriptor.Name == "AddNumbers");
Assert.NotNull(methodDescriptors);
Assert.Equal(methodDescriptors.First().Name, "AddNumbers");
}
public void GetHubMethodFromInvalidHub()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
// There is no ________________CoreTestHubWithMethod________________ name
var methodDescriptor = hubManager.GetHubMethod("________________CoreTestHubWithMethod________________", "AddNumbers", new IJsonValue[] { null, null });
Assert.Null(methodDescriptor);
}
public void GetValidHub()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptor = hubManager.GetHub("CoreTestHub");
Assert.NotNull(hubDescriptor);
Assert.False(hubDescriptor.NameSpecified);
}
public void GetValidHubsWithValidPredicate()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptors = hubManager.GetHubs(descriptor => descriptor.Name == "CoreTestHub");
Assert.NotNull(hubDescriptors);
Assert.Equal(hubDescriptors.First().Name, "CoreTestHub");
}
public void GetInvalidHubMethod()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
// The AddNumbers method has 2 parameters, so should not find the method
var methodDescriptor = hubManager.GetHubMethod("CoreTestHubWithMethod", "AddNumbers", null);
Assert.Null(methodDescriptor);
}
public void GetValidHubMethodsWithInvalidPredicate()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var methodDescriptors = hubManager.GetHubMethods("CoreTestHubWithMethod", descriptor => descriptor.Name == "______AddNumbers______");
// Still have an ienumerable sequence
Assert.NotNull(methodDescriptors);
// But there's nothing in the ienumerable
Assert.Empty(methodDescriptors);
}
public void GetValidHubsWithInvalidPredicate()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptors = hubManager.GetHubs(descriptor => descriptor.Name == "CoreTestHub_INVALIDHUB_____");
// Still have an ienumerable sequence
Assert.NotNull(hubDescriptors);
// But there's nothing in the ienumerable
Assert.Empty(hubDescriptors);
}
public SignalrHubinator(string assemblyPath)
{
_assemblyRootFolder = Path.GetDirectoryName(assemblyPath);
LoadAssemblyIntoAppDomain(assemblyPath);
_typeHelper = new TypeHelper();
var defaultDependencyResolver = new DefaultDependencyResolver();
_hubmanager = new DefaultHubManager(defaultDependencyResolver);
}
public void GetValidHubsWithoutPredicate()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var hubDescriptors = hubManager.GetHubs(predicate: null);
Assert.NotNull(hubDescriptors);
HubDescriptor coreTestHub = hubDescriptors.First(descriptor => descriptor.Name == "CoreTestHub");
Assert.NotNull(coreTestHub);
}
public void EnsureHubSuccessfullyResolves()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var TestHubName = "CoreTestHubWithMethod";
HubDescriptor hub = null,
actualDescriptor = hubManager.GetHub(TestHubName);
hub = hubManager.EnsureHub(TestHubName);
Assert.Equal(hub, actualDescriptor);
}
public SpeechServices(IDependencyResolver Resolver)
{
DefaultHubManager LemurianResolver = new DefaultHubManager(Resolver);
LemurianHub = LemurianResolver.ResolveHub("LemuriaHub") as LemuriaHub;
LemurianHub.LemurianSignal("messenger");
if (MovementTimer == null)
{
MovementTimer = new Timer();
MovementTimer.Elapsed += MovementTimer_Tick;
MovementTimer.AutoReset = false;
}
}
public static Hub Resolve <T>(string hubName = null)
where T : Hub
{
var hm = new DefaultHubManager(GlobalHost.DependencyResolver);
if (hubName == null)
{
hubName = typeof(T).Name;
}
var hub = hm.ResolveHub(hubName) as T;
return(hub);
}
public void MatchSuccessful()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
// Should be AddNumbers
MethodDescriptor methodDescriptor = hubManager.GetHubMethod("CoreTestHubWithMethod", "AddNumbers", new IJsonValue[] { null, null });
// We should find our method descriptor
Assert.NotNull(methodDescriptor);
// Value does not matter, hence the null;
Assert.True(methodDescriptor.Matches(new IJsonValue[] { null, null }));
}
public void GetHubsWithInvalidHubThrows()
{
var hub = new HubDescriptor()
{
Name = "this.is.not.valid"
};
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IHubDescriptorProvider), () => new TestHubDescriptorProvider(hub));
var hubManager = new DefaultHubManager(resolver);
var ex = Assert.Throws <InvalidOperationException>(() => hubManager.GetHubs());
Assert.Equal(string.Format(Resources.Error_HubNameIsInvalid, hub.Name), ex.Message);
}
public void GetValidHubMethod()
{
var resolver = new DefaultDependencyResolver();
var hubManager = new DefaultHubManager(resolver);
var methodDescriptor = hubManager.GetHubMethod("CoreTestHubWithMethod", "AddNumbers", new IJsonValue[] { null, null });
Assert.NotNull(methodDescriptor);
Assert.Equal(methodDescriptor.Name, "AddNumbers");
Assert.Equal(methodDescriptor.ReturnType, typeof(int));
IList <ParameterDescriptor> parameters = methodDescriptor.Parameters;
Assert.Equal(parameters.Count, 2);
Assert.Equal(parameters[0].Name, "first");
Assert.Equal(parameters[0].ParameterType, typeof(int));
Assert.Equal(parameters[1].Name, "second");
Assert.Equal(parameters[1].ParameterType, typeof(int));
}
public void GetHubsDoesNotThrowIfPredicateSkipsInvalidHub()
{
var invalidHub = new HubDescriptor()
{
Name = "this.is.not.valid"
};
var validHub = new HubDescriptor()
{
Name = "thisisvalid"
};
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IHubDescriptorProvider), () => new TestHubDescriptorProvider(invalidHub, validHub));
var hubManager = new DefaultHubManager(resolver);
Assert.Collection(
hubManager.GetHubs(h => !h.Name.Contains(".")),
h => Assert.Equal(validHub.Name, h.Name));
}
protected override void PreStart()
{
var hubManager = new DefaultHubManager(GlobalHost.DependencyResolver);
_hub = hubManager.ResolveHub("serviceStatusHub") as ServiceStatusHub;
}
public TodoHubService()
{
DefaultHubManager hubManager = new DefaultHubManager(GlobalHost.DependencyResolver);
_todoHub = hubManager.ResolveHub("TodoHub") as TodoHub;
}
public ActionResult Details(Bid bid)
{
int currentListingID = Convert.ToInt32(Session["CurrentListingID"]);
Listing currentListingOwner = db.Listings.FirstOrDefault(l => l.ListingID == currentListingID);
int currentListingOwnerID = currentListingOwner.UserID;
// Check if the link is valid
if (ModelState.IsValid)
{
// Check if the user's different from the listing owner
if (currentListingOwnerID != Convert.ToInt32(Session["CurrentUserID"]))
{
// Check for consecutive bids
Listing listing = db.Listings.Find(currentListingID);
// Dirty workaround
Bid latestBid = null;
foreach (var b in listing.Bids.OrderByDescending(l => l.Timestamp).Take(1))
{
latestBid = b;
}
// Can't bid on finished auctions
if (listing.EndTimestamp.Subtract(DateTime.Now).Seconds > 0)
{
// Can't bid on the same auction twice
if (latestBid == null || latestBid.UserID != Convert.ToInt32(Session["CurrentUserID"]))
{
// Amount must be greater than the last bid and starting big
if ((latestBid == null && bid.Amount >= listing.StartingPrice) ||
(latestBid != null && bid.Amount > latestBid.Amount))
{
if (latestBid == null)
{
ViewBag.CurrentPrice = listing.StartingPrice;
}
else
{
ViewBag.CurrentPrice = bid.Amount;
}
bid.UserID = Convert.ToInt32(Session["CurrentUserID"]);
bid.User = db.Users.FirstOrDefault(u => u.UserID == bid.UserID);
bid.ListingID = Convert.ToInt32(Session["CurrentListingID"]);
bid.Listing = db.Listings.FirstOrDefault(l => l.ListingID == bid.ListingID);
bid.Timestamp = DateTime.Now;
db.Bids.Add(bid);
db.SaveChanges();
DefaultHubManager hd = new DefaultHubManager(GlobalHost.DependencyResolver);
var context = GlobalHost.ConnectionManager.GetHubContext <AuctionHub>();
context.Clients.All.addBidToPage(bid.User.Username, bid.Amount.ToString(), bid.Timestamp.ToString(), bid.ListingID.ToString());
return(View(listing));
}
else
{
return(RedirectToAction("Error", new { ErrorID = 5 }));
}
}
else
{
return(RedirectToAction("Error", new { ErrorID = 4 }));
}
}
else
{
return(RedirectToAction("Error", new { ErrorID = 3 }));
}
}
else
{
return(RedirectToAction("Error", new { ErrorID = 2 }));
}
}
return(RedirectToAction("Error", new { ErrorID = 1 }));
}
public ChatController()
{
DefaultHubManager hubManager = new DefaultHubManager(GlobalHost.DependencyResolver);
_chatHub = hubManager.ResolveHub("ChatHub") as ChatHub;
}
protected override void PreStart()
{
var hubManager = new DefaultHubManager(GlobalHost.DependencyResolver);
_hub = hubManager.ResolveHub("sentimentHub") as SignalRHub;
}
protected override void PreStart()
{
var hubManager = new DefaultHubManager(GlobalHost.DependencyResolver);
_hub = hubManager.ResolveHub("notificationHub") as NotificationHub;
}
