public void ShouldBeAbleToMapIdentityToComponent()
{
SignalR.Common.Dto.Identity source = new SignalR.Common.Dto.Identity {
Value = "TEST"
};
With.Component.IIdentity actual = source.AsComponent();
Assert.AreEqual(actual.Value, "TEST");
}
public static void TestInitialize(TestContext context)
{
Identity = A.Fake <With.Component.IIdentity>();
A.CallTo(() => Identity.ToString()).Returns("Identity");
Description = A.Fake <With.Component.IDescription>();
A.CallTo(() => Description.Name).Returns("Name");
A.CallTo(() => Description.Remarks).Returns("Remarks");
EntityDescription = A.Fake <With.Component.IEntityDescription>();
A.CallTo(() => EntityDescription.Type).Returns("Type");
A.CallTo(() => EntityDescription.Manufacturer).Returns("Manufacturer");
A.CallTo(() => EntityDescription.Model).Returns("Model");
A.CallTo(() => EntityDescription.Name).Returns("Name");
A.CallTo(() => EntityDescription.Remarks).Returns("Remarks");
Measurement = A.Fake <With.Component.IMeasurement>();
A.CallTo(() => Measurement.Type).Returns(With.Component.MeasurementType.Seconds);
A.CallTo(() => Measurement.Value).Returns("3.14");
ValueDescription = A.Fake <With.Component.IValueDescription>();
A.CallTo(() => ValueDescription.Name).Returns("Name");
A.CallTo(() => ValueDescription.Remarks).Returns("Remarks");
A.CallTo(() => ValueDescription.Measurement).Returns(With.Component.MeasurementType.Percent);
A.CallTo(() => ValueDescription.Minimum).Returns(Measurement);
A.CallTo(() => ValueDescription.Maximum).Returns(Measurement);
A.CallTo(() => ValueDescription.Default).Returns(Measurement);
Observable = A.Fake <With.Component.IObservable>();
A.CallTo(() => Observable.Identity).Returns(Identity);
A.CallTo(() => Observable.Description).Returns(ValueDescription);
ParameterDescription = A.Fake <With.Component.IParameterDescription>();
A.CallTo(() => ParameterDescription.Name).Returns("Name");
A.CallTo(() => ParameterDescription.Remarks).Returns("Remarks");
A.CallTo(() => ParameterDescription.Measurement).Returns(With.Component.MeasurementType.Percent);
A.CallTo(() => ParameterDescription.Minimum).Returns(Measurement);
A.CallTo(() => ParameterDescription.Maximum).Returns(Measurement);
A.CallTo(() => ParameterDescription.Default).Returns(Measurement);
A.CallTo(() => ParameterDescription.Required).Returns(true);
Parameter = A.Fake <With.Component.IParameter>();
A.CallTo(() => Parameter.Identity).Returns(Identity);
A.CallTo(() => Parameter.Description).Returns(ParameterDescription);
Actionable = A.Fake <With.Component.IActionable>();
A.CallTo(() => Actionable.Identity).Returns(Identity);
A.CallTo(() => Actionable.Description).Returns(Description);
A.CallTo(() => Actionable.Parameters).Returns(new[] { Parameter });
Entity = A.Fake <With.Component.IEntity>();
A.CallTo(() => Entity.Identity).Returns(Identity);
A.CallTo(() => Entity.Description).Returns(EntityDescription);
A.CallTo(() => Entity.Observables).Returns(new[] { Observable });
A.CallTo(() => Entity.Actionables).Returns(new[] { Actionable });
}
public async Task Register(With.Component.IIdentity client, With.Component.IEntity entity, IObserver <Message.IMessage> consumer)
{
Registration.IInstance registration = _registrationFactory.For(client, entity, consumer);
_registrations.Add(registration);
await _hub.Register(registration.Client, registration.Entity);
System.Diagnostics.Debug.WriteLine(string.Format("Client Registered '{0}'", registration.Key));
}
public async Task Observe(With.Component.IIdentity client, With.Component.IIdentity entity, With.Component.IIdentity source, With.Component.IIdentity observable)
{
string registrationKey = Registration.Key.For(client, entity);
Registration.IInstance registration;
if (_registrations.TryGetValue(registrationKey, out registration))
{
await _hub.Observe(client.AsDto(), entity.AsDto(), source.AsDto(), observable.AsDto());
}
}
public async Task Deregister(With.Component.IIdentity client, With.Component.IEntity entity)
{
string registrationKey = Registration.Key.For(client, entity.Identity);
Registration.IInstance registration;
if (_registrations.TryGetValue(registrationKey, out registration))
{
await _hub.Deregister(registration.Client, registration.Entity);
}
}
public Instance(string connectionId, With.Component.IIdentity registrar, With.Component.IEntity entity, Action <With.Message.IMessage> processor)
{
ConnectionId = connectionId;
Registrar = registrar;
Entity = entity;
Key = Registration.Key.For(connectionId, registrar, entity.Identity);
_consumer = new Subject <With.Message.IMessage>();
_subscription = _consumer.Subscribe(processor);
}
public Task Publish(With.Component.IIdentity entity, With.Component.IIdentity observable, DateTimeOffset date, With.Component.IMeasurement measurement)
{
throw new NotImplementedException();
}
public void Perform(With.Component.IIdentity actor, With.Component.IIdentity entity, With.Component.IIdentity actionable, IEnumerable <With.Component.IParameterValue> parameterValues)
{
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForActionBy(entity, actionable), new Message.Action(entity, actionable, actor, parameterValues));
}
public void Publish(With.Component.IIdentity entity, With.Component.IIdentity observable, DateTimeOffset date, With.Component.IMeasurement measurement)
{
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForObservation(entity, observable), new Message.Observation(entity, observable, date, measurement));
}
public void Remove(With.Component.IIdentity registrar, With.Component.IIdentity component)
{
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForRemovalOf(component), new Message.Remove(registrar, component));
_connectionInstance.RemoveQueue(_queueName.For(component));
}
public void Deregister(With.Component.IIdentity entity)
{
//_connectionInstance.PublishDeregistered(entity);
_connectionInstance.Route(_routingKey.ForActionOf(entity)).From(_configurationSettings.ExchangeName).To(_queueName.For(entity)).Stop();
}
public static string For(With.Component.IIdentity registrar, With.Component.IIdentity entity)
{
return(For(registrar.Value, entity.Value));
}
public static Dto.Identity AsDto(this With.Component.IIdentity identity)
{
return(Mapper.Map <Dto.Identity>(identity));
}
public string For(With.Component.IIdentity entity)
{
return(entity.Value);
}
internal static string For(string connectionId, With.Component.IIdentity registrar, With.Component.IIdentity entity)
{
return(For(connectionId, registrar.Value, entity.Value));
}
public Task Perform(With.Component.IIdentity actor, With.Component.IIdentity entity, With.Component.IIdentity actionable, IEnumerable <With.Component.IParameterValue> parameterValues)
{
throw new NotImplementedException();
}
public void Register(With.Component.IIdentity registrar, With.Component.IEntity entity, IObserver <With.Message.IMessage> consumer)
{
_connectionInstance.BuildQueue(_queueName.For(entity.Identity));
_connectionInstance.BindConsumer(_queueName.For(entity.Identity), consumer);
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForRegistrationOf(entity.Identity), new Message.Register(registrar, entity));
}
public void Deregister(With.Component.IIdentity registrar, With.Component.IEntity entity)
{
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForDeregistrationOf(entity.Identity), new Message.Deregister(registrar, entity.Identity));
_connectionInstance.RemoveQueue(_queueName.For(entity.Identity));
}
public void Remove(With.Component.IIdentity component)
{
_connectionInstance.Route(_routingKey.ForRegistration()).From(_configurationSettings.ExchangeName).To(_queueName.For(component)).Stop();
_connectionInstance.Route(_routingKey.ForObservation()).From(_configurationSettings.ExchangeName).To(_queueName.For(component)).Stop();
_connectionInstance.Route(_routingKey.ForAllActions()).From(_configurationSettings.ExchangeName).To(_queueName.For(component)).Stop();
}
public void Observe(With.Component.IIdentity observer, With.Component.IIdentity entity, With.Component.IIdentity observable)
{
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForObserving(entity, observable), new Message.Observe(entity, observable, observer));
}
public void RemoveObserver(With.Component.IIdentity sourceEntity, With.Component.IIdentity observable, With.Component.IIdentity targetEntity)
{
_connectionInstance.Route(_routingKey.ForObservationOf(sourceEntity, observable)).From(_configurationSettings.ExchangeName).To(_queueName.For(targetEntity)).Stop();
}
public void Add(With.Component.IIdentity registrar, With.Component.IComponent component, IObserver <Message.IMessage> consumer)
{
_connectionInstance.BuildQueue(_queueName.For(component.Identity));
_connectionInstance.BindConsumer(_queueName.For(component.Identity), consumer);
_connectionInstance.Publish(_configurationSettings.ExchangeName, _routingKey.ForAdditionOf(component.Identity), new Message.Add(registrar, component));
}
