public void When_request_to_resolve_serviceScope_Should_fail(ServiceProviderType serviceProviderType)
{
/// ServiceScope should be created by the scope factory alone!!
var serviceProvider = CreateServiceProvider(new ServiceCollection(), serviceProviderType);
Assert.Throws <ActivationException>(() => serviceProvider.GetService(typeof(IServiceScope)));
}
public void When_request_UnbindTypeIntfrace_ShouldBeNull(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
Assert.IsNull(serviceProvider.GetService(typeof(IDependency)));
}
public static List<Company> GetCompanies(ServiceProviderType type)
{
List<Company> Companies = new List<Company>();
using (SqlConnection myConnection = new SqlConnection(ConfigurationManager.ConnectionStrings[Connection.ConnectionName].ConnectionString))
{
string sqlstmt = "select id, name, ctype from [dbo].[Company] where ctype=@type";
SqlCommand myCommand = new SqlCommand(sqlstmt, myConnection);
myCommand.CommandType = CommandType.Text;
myCommand.Parameters.AddWithValue("@type", type);
myConnection.Open();
using (SqlDataReader myReader = myCommand.ExecuteReader())
{
Company company;
while (myReader.Read())
{
company = FillDataRecord(myReader);
Companies.Add(company);
}
myReader.Close();
}
myConnection.Close();
}
return Companies;
}
public void When_request_UnbindTypeIntfrace_ShouldThrow(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
Assert.Throws <ActivationException>(() => serviceProvider.GetService(typeof(IDependency)));
}
public static List<ServiceProvider> GetServiceProviderDetails(ServiceProviderType type)
{
List<ServiceProvider> ServiceProviderDetails = new List<ServiceProvider>();
using (SqlConnection myConnection = new SqlConnection(ConfigurationManager.ConnectionStrings[Connection.ConnectionName].ConnectionString))
{
string sqlstmt = "select sp.id,sp.name \"spname\",sp.code,sp.sptype,sp.description,sp.installationcharges,sp.servicecharges,c.name \"companyname\" from [dbo].[ServiceProvider] sp INNER JOIN [dbo].[Company] c ON sp.companyid = c.id where sptype=@type";
SqlCommand myCommand = new SqlCommand(sqlstmt, myConnection);
myCommand.CommandType = CommandType.Text;
myCommand.Parameters.AddWithValue("@type", type);
myConnection.Open();
using (SqlDataReader myReader = myCommand.ExecuteReader())
{
ServiceProvider serviceProvider;
while (myReader.Read())
{
serviceProvider = FillDataRecord(myReader);
ServiceProviderDetails.Add(serviceProvider);
}
myReader.Close();
}
myConnection.Close();
}
return ServiceProviderDetails;
}
/*
* The behavior of Microsoft.Extensions.DependencyInjection.Abstractions seems to have changed between (2.2) => (3.1.3)
* Since we are not using it anymore for Scopes it is not an issue but if we decide to go back to it, this is a strong
* indication that scoped object will leak.
*
* [TestCase(ServiceProviderType.microsoft)]
*/
public void When_scope_dispose_should_realece_referaces_to_scope_dependency(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var serviceScopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
var scope = serviceScopeFactory.CreateScope();
WeakReference <object> holder = null;
Action notRootByDebuger = () =>
{
holder = new WeakReference <object>(scope.ServiceProvider.GetService(typeof(Dependency)));
};
notRootByDebuger();
scope.Dispose();
MakeSomeGarbage();
GC.WaitForFullGCComplete();
GC.WaitForPendingFinalizers();
GC.WaitForFullGCApproach();
GC.Collect(2);
Assert.False(holder.TryGetTarget(out _), "scope object in not rooted, it should be collected");
}
public void WhenScopeServicePointToSingelToneShouldThrow(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection()
.AddSingleton <DependencyDependedOn_Dependency>().AddScoped <Dependency>();
Assert.Throws <DeadlockDetectorExeption>(() => CreateServiceProvider(binding, serviceProviderType));
}
public void When_request_to_resolve_serviceScope_Should_BeNull(ServiceProviderType serviceProviderType)
{
/// ServiceScope should be created by the scope factory alone!!
var serviceProvider = CreateServiceProvider(new ServiceCollection(), serviceProviderType);
var scopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
Assert.IsNull(scopeFactory.CreateScope().ServiceProvider.GetService(typeof(IServiceScope)));
}
public ActionResult DeleteConfirmed(int id)
{
ServiceProviderType branch = InsuranceContext.ServiceProviderTypes.Single(id);
InsuranceContext.ServiceProviderTypes.Delete(branch);
return(RedirectToAction("Index"));
}
public void When_request_UnbindType_ShouldNotBeNull(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var factory = serviceProvider.GetService(typeof(DependencyDependedOn_Dependency));
Assert.IsNotNull(factory);
}
public void ServiceProvider_should_Not_support_Func(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddTransient(typeof(Dependency));
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var factory = (Func <Dependency>)serviceProvider.GetService(typeof(Func <Dependency>));
Assert.IsNull(factory);
}
public void Wheen_resolve_scopeDependcy_with_no_scope_should_use_globalScope(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var a = serviceProvider.GetService <Dependency>();
var b = serviceProvider.GetService <Dependency>();
Assert.AreEqual(a, b);
}
public void GetServicesShouldReturnMultipleServices(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection()
.AddSingleton <IDependency, Dependency2>()
.AddSingleton <IDependency, Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
Assert.AreEqual(2, serviceProvider.GetServices(typeof(IDependency)).Count());
}
public void When_resolve_factory_on_scope_Should_Resolve_Same_Object(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var serviceScopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
var serviceScope = serviceScopeFactory.CreateScope();
var factory = (Func <Dependency>)serviceScope.ServiceProvider.GetService(typeof(Func <Dependency>));
Assert.Throws <GlobalScopeNotSupportFromNinject>(() => factory());
}
public void When_Resolve_ScopeDependcy_After_The_Scope_Dispose_Should_Throw(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var serviceScopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
var scope = serviceScopeFactory.CreateScope();
scope.Dispose();
Assert.Throws <ObjectDisposedException>(() => scope.ServiceProvider.GetService(typeof(Dependency)));
}
/// <summary>
/// Disconnect from a remote host.
/// </summary>
public void Disconnect()
{
if (_handle == null)
{
throw new InvalidOperationException("No connection established");
}
_handle.Disconnect();
_handle = null;
_serviceProviderType = ServiceProviderType.None;
}
public Receipt MakePayment(PaymentModel paymentModel, ServiceProviderType serviceProviderType, IBill bill)
{
return(new Receipt()
{
ReceiptId = (new Random()).Next(),
ReceiptNo = "12df",
ReceiptAmount = 23,
GeneratedDate = DateTime.Today,
Customer = new Customer()
});
}
public static ServiceProviderType MapToClient(ServiceProviderType serviceProviderType)
{
ServiceProviderType mappedServiceProviderType = new ServiceProviderType
{
Active = serviceProviderType.Active,
Id = serviceProviderType.Id,
Name = serviceProviderType.Name
};
return(mappedServiceProviderType);
}
public void When_disposeing_scope_should_dispose_of_all_scope_dependency(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>().AddScoped <DisposableDependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var serviceScopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
//Scope 1
var serviceScope = serviceScopeFactory.CreateScope();
DisposableDependency object1 = (DisposableDependency)serviceScope.ServiceProvider.GetService(typeof(DisposableDependency));
serviceScope.Dispose();
Assert.AreEqual(object1.DisposeCounter, 1);
}
public void When_Resolve_IEnumerable_should_return_multiple_Binding(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection()
.AddSingleton(typeof(IDependency), typeof(Dependency))
.AddSingleton(typeof(IDependency), typeof(Dependency2)
);
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var object1 = (IEnumerable <IDependency>)serviceProvider.GetService(typeof(IEnumerable <IDependency>));
Assert.AreEqual(2, object1.Count());
}
// GET: Home/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ServiceProviderType branch = InsuranceContext.ServiceProviderTypes.Single(id);
if (branch == null)
{
return(HttpNotFound());
}
return(View(branch));
}
public IServiceProvider GetServiceProvider(ServiceProviderType ProviderType)
{
switch (ProviderType)
{
case ServiceProviderType.Electicity:
return(new ElectricityServiceProvider());
case ServiceProviderType.Mobile:
return(new MobileServicProvider());
default:
throw new NotImplementedException();
}
}
public void KeyedServiceCollection_should_support_multiple_named_binding(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection()
.AddSingleton <Dependency2>().AddSingleton <Dependency>()
.AddSingletonNamedService <IDependency>("A", (s, k) => { return(s.GetService <Dependency2>()); })
.AddSingletonNamedService <IDependency>("B", (s, k) => { return(s.GetService <Dependency>()); });
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var object1 = (IKeyedServiceCollection <string, IDependency>)serviceProvider.GetService(typeof(IKeyedServiceCollection <string, IDependency>));
Assert.AreEqual(typeof(Dependency2), object1.GetService(serviceProvider, "A").GetType());
Assert.AreEqual(typeof(Dependency), object1.GetService(serviceProvider, "B").GetType());
}
public Receipt MakePayment(PaymentModel paymentModel, ServiceProviderType serviceProviderType, IBill bill)
{
IServiceProvider serviceProvider = serviceProviderFactory.GetServiceProvider(serviceProviderType);
IService service = serviceProvider.GetService(bill.ServiceName);
var payment = paymentDAL.MakePayment(paymentModel);
if (payment.Value > 0)
{
return(service.GenerateReceipt(bill));
}
else
{
throw new Exception("Payment failure.");
}
}
public void When_request_ServiceProvider_Sholud_inherit_the_Scope(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddScoped <Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
var serviceScopeFactory = (IServiceScopeFactory)serviceProvider.GetService(typeof(IServiceScopeFactory));
//Scope 1
var serviceScope = serviceScopeFactory.CreateScope();
var object1 = serviceScope.ServiceProvider.GetService(typeof(Dependency));
var serviceProviderInheritScope = (IServiceProvider)serviceScope.ServiceProvider.GetService(typeof(IServiceProvider));
var object2 = serviceProviderInheritScope.GetService(typeof(Dependency));
Assert.AreEqual(object1, object2);
}
internal IServiceProvider CreateServiceProvider(IServiceCollection binding, ServiceProviderType serviceProviderType)
{
if (serviceProviderType == ServiceProviderType.microdot)
{
IKernel kernel = new StandardKernel(new NinjectSettings {
ActivationCacheDisabled = true
});
var registerBinding = new Ninject.Host.NinjectOrleansBinding.OrleansToNinjectBinding(kernel);
registerBinding.ConfigureServices(binding);
return(kernel.Get <IServiceProvider>());
}
else
{
var services = binding.BuildServiceProvider();
return(services.GetService <IServiceProvider>());
}
}
public ActionResult NetBanking(PaymentModel modelobj, ServiceProviderType serviceProviderType, IBill bill)
{
try
{
PaymentBLL bllobj = new PaymentBLL();
var receipt = bllobj.MakePayment(modelobj, serviceProviderType, bill);
ViewBag.Result = "Success";
}
catch (Exception ex)
{
logger.Info(ex.Message);
logger.Debug(ex.Message);
}
return(View());
}
public static AMQPServiceProvider CreateServiceProvider(
ServiceProviderType type,
string ServiceNamespace,
string SASKeyName,
string SASKeyValue)
{
switch (type)
{
case ServiceProviderType.Azure:
return(new AzureServiceProvider(
ServiceNamespace,
SASKeyName,
SASKeyValue));
default:
return(null);
}
}
private protected ServiceProvider <T> WithIntegration <TConfiguration>(ServiceProviderType serviceProviderType, TConfiguration configuration, string serviceKey)
where TConfiguration : Configuration, new()
{
if (configuration == default)
{
configuration = new TConfiguration()
{
Name = ReflectionHelper.NameOfCallingClass(2)
}
}
;
else if (configuration.Name == default)
{
configuration = configuration with {
Name = ReflectionHelper.NameOfCallingClass(2)
}
}
;
RystemServiceProvider.Services.Add(Installation,
new ProvidedService(serviceProviderType, configuration, serviceKey ?? string.Empty));
return(RystemServiceProvider);
}
public void Singleton_Dependency_should_be_rooted(ServiceProviderType serviceProviderType)
{
var binding = new ServiceCollection().AddSingleton <Dependency>();
var serviceProvider = CreateServiceProvider(binding, serviceProviderType);
WeakReference <object> holder = null;
Action notRootByDebuger = () =>
{
holder = new WeakReference <object>(serviceProvider.GetService(typeof(Dependency)));
};
notRootByDebuger();
MakeSomeGarbage();
GC.WaitForFullGCComplete();
GC.WaitForPendingFinalizers();
GC.WaitForFullGCApproach();
GC.Collect(2);
Assert.True(holder.TryGetTarget(out _), "Dependency is rooted to scoped, it should be collected");
}
/// <summary>
/// Connects to a VMWare VI Server, VMWare Server or Workstation.
/// </summary>
private void Connect(ServiceProviderType serviceProviderType,
string hostName, int hostPort, string username, string password, int timeout)
{
try
{
int serviceProvider = (int)serviceProviderType;
VMWareJobCallback callback = new VMWareJobCallback();
using (VMWareJob job = new VMWareJob(new VixLib().Connect(
Constants.VIX_API_VERSION, serviceProvider, hostName, hostPort,
username, password, 0, null, callback), callback))
{
_handle = job.Wait <IHost>(Constants.VIX_PROPERTY_JOB_RESULT_HANDLE, timeout);
}
_serviceProviderType = serviceProviderType;
}
catch (Exception ex)
{
throw new Exception(
string.Format("Failed to connect: serviceProviderType=\"{0}\" hostName=\"{1}\" hostPort={2} username=\"{3}\" timeout={4}",
Enum.GetName(serviceProviderType.GetType(), serviceProviderType), hostName, hostPort, username, timeout), ex);
}
}
/// <summary>
/// Connects to a VMWare VI Server, VMWare Server or Workstation.
/// </summary>
private void Connect(ServiceProviderType serviceProviderType,
string hostName, int hostPort, string username, string password, int timeout)
{
try
{
// check if VmWare COM object could be loaded
// if we try to load a COM object which does not exist, an RCW exception will occure on exit of Visual Studio 2013
using (RegistryKey baseKey = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry32)) {
using (var xReg = baseKey.OpenSubKey(@"CLSID\{6874E949-7186-4308-A1B9-D55A91F60728}", false)) {
if (xReg == null)
{
throw new ApplicationException("No Vmware Library installed!");
}
}
}
int serviceProvider = (int)serviceProviderType;
VMWareJobCallback callback = new VMWareJobCallback();
using (VMWareJob job = new VMWareJob(new VixLib().Connect(
Constants.VIX_API_VERSION, serviceProvider, hostName, hostPort,
username, password, 0, null, callback), callback))
{
_handle = job.Wait <IHost>(Constants.VIX_PROPERTY_JOB_RESULT_HANDLE, timeout);
}
_serviceProviderType = serviceProviderType;
}
catch (ApplicationException)
{
throw;
}
catch (Exception ex)
{
throw new Exception(
string.Format("Failed to connect: serviceProviderType=\"{0}\" hostName=\"{1}\" hostPort={2} username=\"{3}\" timeout={4}",
Enum.GetName(serviceProviderType.GetType(), serviceProviderType), hostName, hostPort, username, timeout), ex);
}
}
public static AuthenticationProperties CreateProperties(string userName, string Roles, string userId, string deviceType, string deviceToken, int planId, bool IsRegister, bool IsLogin, ServiceProviderType type)
{
IDictionary<string, string> data = new Dictionary<string, string>
{
{ "userName", userName },
{"roles",Roles},
{"userId",userId},
{"deviceType", deviceType},
{"deviceToken", deviceToken},
{"planId",planId.ToString() },
{"IsRegister",IsRegister.ToString() },
{"IsLogin",IsLogin.ToString() },
{"type",type.ToString() }
};
return new AuthenticationProperties(data);
}
/// <summary>
/// Agrega un nuevo proveedor si este no existe
/// </summary>
/// <param name="name"></param>
/// <param name="sourceInfo"></param>
/// <param name="applicationId"></param>
/// <param name="type"></param>
public void AddNewProvider(string name, string sourceInfo, string applicationId, ServiceProviderType type)
{
ServiceProviderElement p = new ServiceProviderElement();
p.Name = name;
p.SourceInfo = sourceInfo;
p.ApplicationId = applicationId;
p.ProviderType = type;
this.AddNewProvider(p);
}
