private void DebugServiceMethods()
{
var service = DummyService.Create();
// Call a method without caching.
Debug.WriteLine(service.DummyMethodNoCaching());
// Call a cached method twice.
Debug.WriteLine(service.DummyMethodCached());
Debug.WriteLine(service.DummyMethodCached());
// Call a cached method with one second expiration 6 times with an interval of 500 miliseconds.
for (int i = 0; i < 6; i++)
{
Debug.WriteLine(service.DummyMethodCachedExpireInOneSecond());
Thread.Sleep(500);
}
// Call a cached method with arguments twice.
Debug.WriteLine(service.DummyMethodWithArguments(1, "Hello world!"));
Debug.WriteLine(service.DummyMethodWithArguments(1, "Hello world!"));
// Call the same cached method with different arguments twice.
Debug.WriteLine(service.DummyMethodWithArguments(2, "Hello unit test!"));
Debug.WriteLine(service.DummyMethodWithArguments(2, "Hello unit test!"));
// Output a list of all the stored cache keys.
Debug.WriteLine(string.Join(Environment.NewLine, new CacheHandler().GetAllCachedObjects()
.Select(x => string.Concat("Key: ", x.Key, " Expires on: ", x.Expiration.ToString("yyyy-MM-dd HH:mm:ss:fff")))));
}
public void AsyncInvocation()
{
TestMethodImpl baseMethod = new TestMethodImpl();
WarpedMethodImpl warpedMethod = new WarpedMethodImpl(baseMethod, typeof(Thing),
TypeDescriptor.GetProperties(typeof(Thing)),
TypeDescriptor.GetProperties(typeof(ResultThing))[0]);
DummyService service = new DummyService();
object[] args = new object[] { 42, "foobar" };
baseMethod.InvokeResult = new ResultThing(123);
IAsyncResult ar = warpedMethod.BeginInvoke(service, args, null, null);
object result = warpedMethod.EndInvoke(service, ar);
Assert.AreSame(ar, baseMethod.EndInvokeAsyncResult);
Assert.AreSame(service, baseMethod.InvokeService);
Assert.IsNotNull(baseMethod.InvokeArgs);
Assert.AreEqual(1, baseMethod.InvokeArgs.Length);
Assert.IsNotNull(baseMethod.InvokeArgs[0]);
Thing thing = baseMethod.InvokeArgs[0] as Thing;
Assert.IsInstanceOfType(typeof(Thing), thing);
Assert.AreEqual(args[0], thing.Int);
Assert.AreEqual(args[1], thing.Str);
Assert.AreEqual(baseMethod.InvokeResult.Result, result);
}
public void ServiceProviderSystemAPI_Test()
{
var coreService = new Mock <IServiceContainer>();
IDictionary <Type, object> serviceContainer = new Dictionary <Type, object>();
coreService.Setup(c => c.RegisterService(It.IsAny <IDummyComposable>())).Callback <IDummyComposable>(d =>
serviceContainer
.Add(typeof(IDummyComposable), d));
coreService.Setup(c => c.AvailableServices())
.Returns(() => serviceContainer.Keys.Select(service => service.FullName));
coreService.Setup(c => c.Get <IDummyComposable>())
.Returns(() => (IDummyComposable)serviceContainer[typeof(IDummyComposable)]);
coreService.Setup(c => c.Get(typeof(IDummyComposable)))
.Returns(() => (IDummyComposable)serviceContainer[typeof(IDummyComposable)]);
var dummyService = new DummyService();
var provider = new ServiceRegistrationProvider(coreService.Object);
provider.RegisterService <IDummyComposable>(dummyService);
Assert.Contains(typeof(IDummyComposable), serviceContainer.Keys);
Assert.Equal(dummyService, serviceContainer[typeof(IDummyComposable)]);
var serviceProvider = new ServiceProvider(coreService.Object,
new List <string>()
{
typeof(IDummyComposable).FullName
});
Assert.Equal(dummyService, serviceProvider.ToServiceProvider().GetService(typeof(IDummyComposable)));
}
public static void Main(string[] args)
{
var service = new DummyService();
System.Console.WriteLine("Iteration Zero ... Service.Foo(): {0}", service.Foo());
System.Console.ReadLine();
}
public void FindAll_ReturnsExpectedData()
{
// Arrange
DummyEntity[] data =
{
new DummyEntity {
Name = "Some Name", Id = 1
},
new DummyEntity {
Name = "Other Name", Id = 2
}
};
Mock <IDummyRepository> dummyRepository = new Mock <IDummyRepository>();
dummyRepository.Setup(e => e.FindAll()).Returns(data);
IDummyService service = new DummyService(dummyRepository.Object);
// Act
IEnumerable <DummyEntity> result = service.FindAll();
// Assert
CollectionAssert.AreEqual(data, result.ToArray());
}
public void AsyncInvocation()
{
TestMethodImpl baseMethod = new TestMethodImpl();
WarpedMethodImpl warpedMethod = new WarpedMethodImpl(baseMethod, typeof(Thing),
TypeDescriptor.GetProperties(typeof(Thing)),
TypeDescriptor.GetProperties(typeof(ResultThing))[0]);
DummyService service = new DummyService();
object[] args = new object[] { 42, "foobar" };
baseMethod.InvokeResult = new ResultThing(123);
IAsyncResult ar = warpedMethod.BeginInvoke(service, args, null, null);
object result = warpedMethod.EndInvoke(service, ar);
Assert.AreSame(ar, baseMethod.EndInvokeAsyncResult);
Assert.AreSame(service, baseMethod.InvokeService);
Assert.IsNotNull(baseMethod.InvokeArgs);
Assert.AreEqual(1, baseMethod.InvokeArgs.Length);
Assert.IsNotNull(baseMethod.InvokeArgs[0]);
Thing thing = baseMethod.InvokeArgs[0] as Thing;
Assert.IsInstanceOfType(typeof(Thing), thing);
Assert.AreEqual(args[0], thing.Int);
Assert.AreEqual(args[1], thing.Str);
Assert.AreEqual(baseMethod.InvokeResult.Result, result);
}
public void Add_ShouldReturnSum <T>(T a, T b)
{
var sut = DummyService.Add(a, b); // sut = System Under Test
var expected = (dynamic)a + b;
Assert.Equal(expected, sut);
}
public void Insert(InsertDummyServiceDto dto)
{
DummyService dummyService = new DummyService(dto.Request, dto.Response);
string jsonDetails = _jsonSerializer.Serialize(dummyService);
Service service = new Service(dto.Name, ServiceType.DUMMY, jsonDetails);
_serviceRepository.Insert(service);
}
public void Service_FindCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var key = A.Dummy<int>();
sut.Find(key);
A.CallTo(() => rep.Find(key)).MustHaveHappened();
}
public void Given_Service_Throwing_SandraValidationException_Should_Contain_Results()
{
var validationService = new ValidationService();
var dummyService = new DummyService(validationService);
var testUser = new User();
Assert.Throws <SandraValidationException>(() => dummyService.DoSomething(testUser));
}
public async Task Service_FindAsyncCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var key = A.Dummy<int>();
var res = await sut.FindAsync(key);
A.CallTo(() => rep.FindAsync(key)).MustHaveHappened();
}
public void Service_FindThrowIfInvalidOperationException()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var key = A.Dummy<int>();
A.CallTo(() => rep.Find(key)).Throws<InvalidOperationException>();
var sut = new DummyService(rep);
Action a = () => sut.Find(key);
a.ShouldThrow<NoDataFoundException>();
}
public void Service_FindThrowIfGenericException()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var key = A.Dummy<int>();
A.CallTo(() => rep.Find(key)).Throws<Exception>();
var sut = new DummyService(rep);
Action a = () => sut.Find(key);
a.ShouldThrow<DistribuitedException>();
}
public void Test020()
{
using var sut = new TestServiceProvider();
var expected = new DummyService();
sut.AddSingleton(expected);
var actual = sut.GetService <DummyService>();
actual.ShouldBe(expected);
}
public ActionResult <IEnumerable <string> > Get([FromServices] DummyService dummyService1, [FromServices] IDummyService dummyService2, [FromServices] Microsoft.Extensions.Configuration.IConfiguration options)
{
return(new string[] {
"value1",
"value2",
dummyService1.Ping(),
dummyService2.Ping(),
dummyService1.GetConfiguration("ORAGON_SPRING_ENVIRONMENT_VAR"),
dummyService2.GetConfiguration("ORAGON_SPRING_ENVIRONMENT_VAR")
});
}
public void ServiceContainer_RegisterTest()
{
var appDataDirectory = new DirectoryInfo(Path.GetTempPath())
.CreateSubdirectory(Guid.NewGuid().ToString());
var container = new ServiceContainer(appDataDirectory.FullName);
IDummyComposable dummy = new DummyService();
container.RegisterService(dummy);
Assert.Equal(dummy, container.Get <IDummyComposable>());
Assert.Contains(typeof(IDummyComposable).FullName, container.AvailableServices());
}
public ScopedProcessingService(NtoboaFundDbContext _context, IHubContext <StakersHub> _stakersHub,
IHubContext <CountdownHub> _countdownHub, IHubContext <WinnerSelectionHub> _winnerSelectionHub,
MessagingService messagingService, StakersHub dataHub, DummyService dummyService)
{
context = _context;
CountdownHub = _countdownHub;
StakersHub = _stakersHub;
WinnerSelectionHub = _winnerSelectionHub;
MessagingService = messagingService;
DataHub = dataHub;
DummyService = dummyService;
}
public void ShouldReturnSameServiceObject_AfterRegisteringIt()
{
// Arrange
var service = new DummyService();
underTest.RegisterService(service);
// Act
var result = underTest.GetService<DummyService>();
// Assert
Assert.That(result, Is.SameAs(service));
}
public IList <DummyServiceDto> GetAll()
{
IList <DummyServiceDto> dto = new List <DummyServiceDto>();
IList <Service> services = _serviceRepository.GetByServiceType(ServiceType.DUMMY);
foreach (var s in services)
{
DummyService dummyService = _jsonSerializer.Deserialize <DummyService>(s.JsonDetails);
dto.Add(dummyService.ToDto());
}
return(dto);
}
public void ShouldReturnSameServiceObject_AfterRegisteringIt()
{
// Arrange
var service = new DummyService();
underTest.RegisterService(service);
// Act
var result = underTest.GetService <DummyService>();
// Assert
Assert.That(result, Is.SameAs(service));
}
public static DummyServiceDto ToDto(this DummyService entity)
{
if (entity == null)
{
return(null);
}
DummyServiceDto dto = new DummyServiceDto();
dto.Request = entity.Request;
dto.Response = entity.Response;
return(dto);
}
public void TestMultiRegistration()
{
var firstService = new DummyService();
var secondService = new OtherDummyService();
Container.RegisterInstance <IDummyService>(firstService, registrationMode: ServiceRegistrationMode.Append);
Container.RegisterInstance <IDummyService>(secondService, registrationMode: ServiceRegistrationMode.Append);
var services = Container.ResolveAll <IDummyService>();
Assert.NotNull(services);
Assert.Contains(firstService, services);
Assert.Contains(secondService, services);
}
public void GetService_ShouldResolveServicesFromLifetimeScope()
{
// Arrange
var builder = new ContainerBuilder();
var service = new DummyService();
builder.RegisterInstance(service);
var scope = new ServiceScope(builder.Build());
// Act
var result = scope.GetService(typeof(DummyService));
// Assert
result.Should().Be(service);
}
public BaseDummyTest(AutomapperFixture automapperFixture)
{
SetupMockDummyRepository();
SetupMockPersitance();
SetupDummyInMemoryList();
Service = new DummyService(
automapperFixture.Mapper,
MockDummyRepository.Object,
MockUnitOfWork.Object,
new Mock <ILog <DummyService> >().Object,
new UpdateDummyContractValidator(),
new CreateDummyContractValidator());
}
public void RegisterSingletonInstanceAbstractions()
{
using (var sut = CreateContainer())
{
var dummyInstance0 = new DummyService();
sut.AddSingleton <IDummyService>(dummyInstance0);
var dummyInstance1 = sut.Resolve <IDummyService>();
var dummyInstance2 = sut.Resolve <IDummyService>();
Assert.AreSame(dummyInstance0, dummyInstance1);
Assert.AreSame(dummyInstance0, dummyInstance2);
Assert.AreSame(dummyInstance1, dummyInstance2);
}
}
public void Given_Service_Throwing_SandraValidationException_Should_Contain_One_Message()
{
var validationService = new ValidationService();
var dummyService = new DummyService(validationService);
var testUser = new User();
try
{
dummyService.DoSomething(testUser);
}
catch (SandraValidationException sve)
{
Assert.Equal(1, sve.Result.Messages.Count);
}
}
public void ValueChangedEventWorks([Random(1, int.MaxValue, 1)] int a, [Random(int.MinValue, 0, 1)] int b)
{
bool hasService = ServiceLocator.Shared.TryGet(out IDummyService service);
Assert.That(hasService, Is.False);
Assert.That(service, Is.Null);
IDummyService serviceA = new DummyService
{
Value = a,
};
IDummyService serviceB = new DummyService
{
Value = b,
};
public void AddService(string technicalName)
{
var contexts = from PluginContext p in _pluginDiscovery where p.PluginInfo.TechnicalName == technicalName select p; // todo: _plugin discovery might need to be refreshed, maybe use a directory whatcher or something.
if (contexts.Count() == 0)
{
throw new Exception(string.Format("Plugin with technical name {0} not found.", technicalName));
}
var context = contexts.Single();
var service = new DummyService()
{
IdentifyableTechnicalName = context.PluginInfo.TechnicalName
};
base.AddService(service);
}
public void GetService_ShouldResolveServicesFromServiceScope()
{
// Arrange
var service = new DummyService();
var microsoftServiceScopeMock = new Mock <IServiceScope>();
var systemServiceProviderMock = new Mock <IServiceProvider>();
microsoftServiceScopeMock.SetupGet(x => x.ServiceProvider).Returns(systemServiceProviderMock.Object);
systemServiceProviderMock.Setup(x => x.GetService(typeof(DummyService))).Returns(service);
var scope = new ServiceScope(microsoftServiceScopeMock.Object);
// Act
var result = scope.GetService(typeof(DummyService));
// Assert
result.Should().Be(service);
}
public void GetComponentTyped_WhenComponentCanBeResolved_ReturnsAndMemoizesIt()
{
var component = MockRepository.GenerateStub <DummyService>();
var componentDescriptor = CreateStubComponentDescriptor <DummyService, DummyTraits>();
var componentHandle = ComponentHandle.CreateInstance <DummyService, DummyTraits>(componentDescriptor);
componentDescriptor.Expect(x => x.ResolveComponent()).Return(component);
// first time
DummyService result = componentHandle.GetComponent();
Assert.AreSame(component, result);
// second time should be same but method only called once
result = componentHandle.GetComponent();
Assert.AreSame(component, result);
componentDescriptor.VerifyAllExpectations();
}
private void btnLogHelper_Click(object sender, EventArgs e)
{
DummyService dummy = new DummyService();
//呼叫無參數method
LogHelper.Excute(() => dummy.DoSomething());
//呼叫有參數method
LogHelper.Excute(() => dummy.DoSomethingWithArgs(123));
//呼叫複雜型別參數method
ProductViewModel vm = new ProductViewModel {
ProductName = "product name"
};
LogHelper.Excute(() => dummy.DoSomethingWithComplexArgs(vm));
//使用TryExecute並判斷結果是否成功
ExecutedResult <ProductViewModel> result = LogHelper.TryExcute <ProductViewModel>(() => dummy.BadPerformanceMethod("myId", "TWD", "myName"));
if (result.IsSuccess)
{
logger.DebugFormat("IsSuccess: {0}, ProductName: {1}", result.IsSuccess, result.Result.ProductName);
}
else
{
logger.Debug("execute failed");
}
//使用TryExecute並判斷結果是否成功
ExecutedResult <ProductViewModel> result2 = LogHelper.TryExcute <ProductViewModel>(() => dummy.FailedMethod("myId", "TWD", "myName"));
if (result2.IsSuccess)
{
logger.DebugFormat("IsSuccess: {0}, ProductName: {1}", result.IsSuccess, result.Result.ProductName);
}
else
{
logger.Debug("execute failed");
}
}
public void ResolveSameSingleInstanceEvenOutsideOfScope()
{
using (var sut = CreateContainer())
{
var dummyService0 = new DummyService();
sut.AddSingleton(dummyService0);
DummyService dummyService1;
using (var scope = sut.CreateScope())
{
dummyService1 = scope.Resolve <DummyService>();
Assert.That(dummyService0, Is.EqualTo(dummyService1));
}
// Just to confirm after disposing the scope
Assert.That(dummyService0, Is.EqualTo(dummyService1));
var dummyService2 = sut.Resolve <DummyService>();
Assert.That(dummyService0, Is.EqualTo(dummyService2));
Assert.That(dummyService1, Is.EqualTo(dummyService2));
}
}
public void Service_QueryWithExpressionReturnIQueryFluent()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
Expression<Func<DummyEntity, bool>> exp = x => x.Id == 1;
var sut = new DummyService(rep);
var res = sut.Query(exp);
A.CallTo(() => rep.Query(exp)).MustHaveHappened();
res.Should().BeAssignableTo<IQueryFluent<DummyEntity>>();
}
public void Service_QueryWithIQueryObjectReturnIQueryFluent()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var query = A.Dummy<IQueryObject<DummyEntity>>();
A.CallTo(() => rep.Query(query)).Returns(new DummyQueryFluent());
var sut = new DummyService(rep);
var res = sut.Query(query);
A.CallTo(() => rep.Query(query)).MustHaveHappened();
res.Should().BeAssignableTo<IQueryFluent<DummyEntity>>();
}
public void Service_QueryReturnIQueryFluent()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
A.CallTo(() => rep.Query()).Returns(new DummyQueryFluent());
var sut = new DummyService(rep);
var res = sut.Query();
res.Should().BeAssignableTo<IQueryFluent<DummyEntity>>();
}
public void Service_SelectQueryCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var key = A.Dummy<int>();
var q = A.Dummy<string>();
var i = A.Dummy<int>();
var res = sut.SelectQuery(q, i);
A.CallTo(() => rep.SelectQuery(q, i)).MustHaveHappened();
}
public async Task Service_DeleteAsyncCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var key = A.Dummy<int>();
var re = await sut.DeleteAsync(key);
A.CallTo(() => rep.DeleteAsync(CancellationToken.None, key)).MustHaveHappened();
}
public void foo_should_return_bar()
{
var service = new DummyService();
service.Foo().ShouldEqual("bar");
}
public void CalculateFullName_ShouldReturnFullName()
{
var sut = DummyService.CalculateFullName("Marcus", "Olkerud");
Assert.Equal("Marcus Olkerud", sut);
}
public void Service_InsertOrUpdateGraphCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var entity = new DummyEntity();
sut.InsertOrUpdateGraph(entity);
A.CallTo(() => rep.InsertOrUpdateGraph(entity)).MustHaveHappened();
}
public void Service_FindAsyncCancelationTokenThrowIfGenericException()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var key = A.Dummy<int>();
var token = A.Dummy<CancellationToken>();
A.CallTo(() => rep.FindAsync(token, key)).Throws<Exception>();
var sut = new DummyService(rep);
Func<Task> a = async () =>
{
await sut.FindAsync(token, key);
};
a.ShouldThrow<DistribuitedException>();
}
public DepA(DummyService s)
{
}
public DependentService(DummyService dummyService)
{
}
public void Service_IQueryableReturnIQueryable()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var res = sut.Queryable();
A.CallTo(() => rep.Queryable()).MustHaveHappened();
res.Should().BeAssignableTo<IQueryable<DummyEntity>>();
}
public void Service_GetRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var res = sut.Repository;
res.Should().BeAssignableTo<IRepositoryAsync<DummyEntity>>();
}
public CircularService2(DummyService dummyService, CircularService3 circularService3)
{
}
public void Service_InsertGraphRangeCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var entities = new DummyEntity[] { new DummyEntity(), new DummyEntity() };
sut.InsertGraphRange(entities);
A.CallTo(() => rep.InsertGraphRange(entities)).MustHaveHappened();
}
public void Service_DeleteObjectCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var entity = new DummyEntity();
sut.Delete(entity);
A.CallTo(() => rep.Delete(entity)).MustHaveHappened();
}
public async Task Service_FindAsyncCancelationTokenCallRepository()
{
var rep = A.Fake<IRepositoryAsync<DummyEntity>>();
var sut = new DummyService(rep);
var key = A.Dummy<int>();
var token = new System.Threading.CancellationToken();
var res = await sut.FindAsync(token, key);
A.CallTo(() => rep.FindAsync(token, key)).MustHaveHappened();
}
public ServiceBaseTest()
{
service = new DummyService();
Events.Service = service;
}
