public void Given_RepoReturnsNoCustomer_Should_Return_Correct_Shipper()
{
// Arrange
//var lastOrder = new Order
//{
// Id = 1,
// Shipper = new Shipper { Id = 42 }
//};
//var address = new Address
//{
// Id = 1,
// LastOrder = lastOrder
//};
//var customer = new Customer { Address = address };
var repo = Substitute.For <ITraditionalRepository>();
repo.GetCustomer(Arg.Any <int>()).Returns((Customer)null);
//repo.GetAddress(Arg.Any<int>()).Returns(address);
//repo.GetOrder(Arg.Any<int>()).Returns(lastOrder);
var repo2 = Substitute.For <IMonadicRepository>();
var sut = new SomeService(repo, repo2);
// Act
var result = sut.GetShipperOfLastOrderOnCurrentAddress(1);
// Assert
result.Should().NotBeNull();
result.Id.Should().Be(42);
}
public void ServiceInjectedViaProperty()
{
var first = new SomeService()
{
Value = 42,
};
var services = new ServiceCollection()
.MakeTransient <ISomeService>()
.AddContributor <ISomeService>((sp, next) => first)
.ChainPrevious <ISomeService, SomeService2>()
.AddInstance <string>("Text");
var configuration = services.BuildApiConfiguration();
var expected = "Text42";
var value = configuration.GetApiService <ISomeService>().Call();
Assert.Equal(expected, value);
value = configuration.GetApiService <ISomeService>().Call();
Assert.Equal(expected, value);
value = configuration.GetApiService <ISomeService>().Call();
Assert.Equal(expected, value);
Assert.NotEqual(
configuration.GetApiService <ISomeService>(),
configuration.GetApiService <ISomeService>());
}
public void TestGetAllWithLambda()
{
var posts = Enumerable.Range(0, 5).Select(x => new Post()
{
Url = string.Format("www.someurl{0}", x)
}).ToList();
for (int i = 0; i < posts.Count; i++)
{
posts[i].PostComments.Add(new PostComment()
{
Comment = string.Format("some test comment {0}", i)
});
}
var queryablePosts = posts.AsQueryable();
var dbsetMock = CreateMockSet(queryablePosts);
var mockContext = new Mock <SachaContextTestDouble>();
mockContext.Setup(c => c.Posts).Returns(dbsetMock.Object);
var service = new SomeService(mockContext.Object);
Func <Post, bool> func = (x) => x.Url == "www.someurl1";
Expression <Func <Post, bool> > filter = post => func(post);
var retrievedPosts = service.GetAll(filter);
CollectionAssert.AreEqual(posts.Where(func).ToList(), retrievedPosts.ToList());
}
static void Main(string[] args)
{
var someService = new SomeService();
var fullName = someService.GetFullName("Mishanya", "Mladzinski");
Console.WriteLine(fullName);
}
static void Main(string[] args)
{
// Теперь мы можем получить экземаляр нашего сервиса и вызывать его метод
SomeService service = SomeService.GetInstance();
Console.Write(service.SayHello());
}
public void TestFindById()
{
Mock <IUnitOfWork> uowMock = new Mock <IUnitOfWork>();
Mock <IRepository <Post> > repoMock = new Mock <IRepository <Post> >();
var posts = Enumerable.Range(0, 5).Select(x => new Post()
{
Id = x,
Url = string.Format("www.someurl{0}", x)
}).ToList();
for (int i = 0; i < posts.Count; i++)
{
posts[i].PostComments.Add(new PostComment()
{
Comment = string.Format("some test comment {0}", i)
});
}
repoMock.Setup(moq => moq.Get(It.IsInRange(0, 5, Range.Inclusive)))
.Returns((int id) => posts.SingleOrDefault(x => x.Id == id));
SomeService service = new SomeService(uowMock.Object, repoMock.Object);
var retrievedPost = service.FindById(2);
Assert.AreEqual(2, retrievedPost.Id);
}
public void TestGetAllWithLambda()
{
Mock <IUnitOfWork> uowMock = new Mock <IUnitOfWork>();
Mock <IRepository <Post> > repoMock = new Mock <IRepository <Post> >();
var posts = Enumerable.Range(0, 5)
.Select(x => new Post()
{
Url = string.Format("www.someurl{0}", x)
}).ToList();
for (int i = 0; i < posts.Count; i++)
{
posts[i].PostComments.Add(new PostComment()
{
Comment = string.Format("some test comment {0}", i)
});
}
repoMock.Setup(moq => moq.GetAll(It.IsAny <Expression <Func <Post, bool> > >()))
.Returns((Expression <Func <Post, bool> > predicate) =>
posts.Where(predicate.Compile()).AsQueryable());
SomeService service = new SomeService(uowMock.Object, repoMock.Object);
Func <Post, bool> func = (x) => x.Url == "www.someurl1";
Expression <Func <Post, bool> > filter = post => func(post);
var retrievedPosts = service.GetAll(filter);
CollectionAssert.AreEqual(posts.Where(func), retrievedPosts);
}
public async void TestFindByIdAsync()
{
Mock <IUnitOfWork> uowMock = new Mock <IUnitOfWork>();
Mock <IRepository <Post> > repoMock = new Mock <IRepository <Post> >();
var posts = Enumerable.Range(0, 5).Select(x => new Post()
{
Id = x,
Url = string.Format("www.someurl{0}", x)
}).ToList();
for (int i = 0; i < posts.Count; i++)
{
posts[i].PostComments.Add(new PostComment()
{
Comment = string.Format("some test comment {0}", i)
});
}
repoMock.Setup(moq => moq.GetIncludingAsync(
It.IsInRange(0, 5, Range.Inclusive),
new[] { It.IsAny <Expression <Func <Post, object> > >() }))
.Returns(
(int id, Expression <Func <Post, object> >[] includes) =>
Task.FromResult(posts.SingleOrDefault(x => x.Id == id)));
SomeService service = new SomeService(uowMock.Object, repoMock.Object);
var retrievedPost = await service.FindByIdAsync(2);
Assert.AreEqual(2, retrievedPost.Id);
}
public async Task GivenJobWithConstructorArgs_ItResolvesThemFromTheContainer()
{
// Arrange
var expected = new SomeService();
var host = new TestServiceHost(
componentRegistrations: b => {
b.RegisterInstance(expected).As <SomeService>();
});
host.Initialize();
var job = new JobDescription("test", typeof(TestJobWithService));
var dispatcher = new JobDispatcher(new[] { job }, host.Container);
var invocation = TestHelpers.CreateInvocation(Guid.NewGuid(), "Test", "test", new Dictionary <string, string>());
var context = new InvocationContext(invocation, queue: null);
var slot = new ContextSlot();
TestJobWithService.SetContextSlot(slot);
// Act
await dispatcher.Dispatch(context);
// Assert
Assert.Same(expected, slot.Value);
}
public ActionResult DoSomething(int value)
{
using (IUnitOfWork scope = new UnitOfWork())
{
ISomeService theService = new SomeService(scope);
theService.SomeMethod(value);
}
public void SomeService_GetMostAmountOfStages_Unittest(int expected, Rocket[] rockets)
{
//Arrange
ISomeService service = new SomeService(new SpaceXDbMock(rockets));
//Act && Assert
Assert.That(service.GetMostAmountOfStages(), Is.EqualTo(expected));
}
public void GetResult_ReturnsExpectedResult()
{
SomeService service = new SomeService();
string result = service.GetResult();
Assert.Equal("hello world!", result);
}
public ReportRepository(IAppCache appCache, ILogger <ShowDatabase> logger, SomeService service)
{
_service = service;
_logger = logger;
_cache = appCache;
}
// Метод для получание экземпляра класса. Если он ещё не инициализирован, то делаем это, после чего возвращаем инстанс
// Это самая простая реализация данного метода. Но у него могут быть проблемы, например, с многопоточностью
// В таком случае, можно сделать использовать оператор lock на каком-нибудь объекте синхронизации, чтобы несколько потоков одновременно не могли переобъявить экземпляр
public static SomeService GetInstance()
{
if (instance == null)
{
instance = new SomeService();
}
return(instance);
}
public override CheckResult PerformCheck()
{
if (SomeService.GetStatus())
{
return(CheckResult.Pass);
}
return(CheckResult.Failed("Some service is not available."));
}
public void Send_should_invoke_Send_of_networkclient()
{
var client = Substitute.For <INetworkClient>();
var msg = "Hello world";
var sut = new SomeService(client);
sut.Send(msg);
client.Received().Send(Arg.Any <byte[]>(), 0, msg.Length + 1);
}
public async Task TestFindByIdAsync()
{
var posts = Enumerable.Range(0, 5).Select(x => new Post()
{
Id = x,
Url = string.Format("www.someurl{0}", x)
}).ToList();
for (int i = 0; i < posts.Count; i++)
{
posts[i].PostComments.Add(new PostComment()
{
Comment = string.Format("some test comment {0}", i)
});
}
var queryablePosts = posts.AsQueryable();
var dbsetMock = new Mock <DbSet <Post> >();
dbsetMock.As <IDbAsyncEnumerable <Post> >()
.Setup(m => m.GetAsyncEnumerator())
.Returns(new TestDbAsyncEnumerator <Post>(queryablePosts.GetEnumerator()));
dbsetMock.As <IQueryable <Post> >()
.Setup(m => m.Provider)
.Returns(new TestDbAsyncQueryProvider <Post>(queryablePosts.Provider));
dbsetMock.As <IQueryable <Post> >().Setup(m => m.Expression).Returns(queryablePosts.Expression);
dbsetMock.As <IQueryable <Post> >().Setup(m => m.ElementType).Returns(queryablePosts.ElementType);
dbsetMock.As <IQueryable <Post> >().Setup(m => m.GetEnumerator()).Returns(queryablePosts.GetEnumerator());
//NOTE : we need to use the string version of Include as the other one that accepts
// an Expression tree is an extension method in System.Data.Entity.QueryableExtensions
// which Moq doesn't like
//
// So the following will not work, as will result in this sort of Exception from Moq
//
// Expression references a method that does not belong to
// the mocked object: m => m.Include<Post,IEnumerable`1>(It.IsAny<Expression`1>())
//
// dbsetMock.Setup(m => m.Include(It.IsAny<Expression<Func<Post,IEnumerable<PostComment>>>>()))
// .Returns(dbsetMock.Object);
dbsetMock.Setup(m => m.Include("PostComments")).Returns(dbsetMock.Object);
var mockContext = new Mock <SachaContextTestDouble>();
mockContext.Setup(c => c.Posts).Returns(dbsetMock.Object);
var service = new SomeService(mockContext.Object);
var retrievedPost = await service.FindByIdAsync(1);
Assert.AreEqual(retrievedPost.Id, 1);
Assert.IsNotNull(retrievedPost.PostComments);
Assert.AreEqual(retrievedPost.PostComments.Count, 1);
}
public void ChangeService()
{
// set the new service instance as
// the ISomeService in the service container
var newService = new SomeService();
_services.RemoveService(typeof(ISomeService), true);
_services.AddService(typeof(ISomeService), newService);
}
public object ExecuteMethod(SomeService someService, object[] parameterValues)
{
var methodCallExpression = _method.Body as MethodCallExpression;
var method = methodCallExpression.Method;
var methodCall = Expression.Call(Expression.Constant(someService), method,
parameterValues.Select(Expression.Constant));
return(Expression.Lambda(methodCall).Compile().DynamicInvoke());
}
public void TestInsert()
{
Mock <IUnitOfWork> uowMock = new Mock <IUnitOfWork>();
Mock <IRepository <Post> > repoMock = new Mock <IRepository <Post> >();
SomeService service = new SomeService(uowMock.Object, repoMock.Object);
service.Insert("TestInsert");
repoMock.Verify(m => m.Add(It.IsAny <Post>()), Times.Once());
}
public void LogsErrorWhenInputIsZero()
{
var mockLogger = new Mock <ILogger <SomeService> >();
var someService = new SomeService(mockLogger.Object);
someService.DoSomething(0);
// Option 1: Try to verify the actual code that was called.
// Doesn't work.
mockLogger.Verify(l => l.LogError(It.IsAny <Exception>(), It.IsAny <string>(), 0));
}
public void Send_is_not_allowed_while_disconnected()
{
var client = Substitute.For <INetworkClient>();
var msg = "Hello world";
var sut = new SomeService(client);
client.Disconnected += Raise.Event();
Action actual = () => sut.Send(msg);
actual.ShouldThrow <InvalidOperationException>();
}
private static void Main(string[] args)
{
var api = RestService.For <ISomeApiClient>("http://localhost/concurency/api");
var mapper = new MapperConfiguration(expression => expression.AddProfile(new DtoMappings())).CreateMapper();
var s = new SomeService(api, mapper);
var m = s.Get(0);
Debug.WriteLine(m.ETag);
s.Update(m);
}
public void TestMethod1()
{
// Arrange
// Act
SomeService service = this.CreateService();
// Assert
}
public void CreateItemWithFixture()
{
// arrange
var f = new Fixture();
var sut = new SomeService();
// act
sut.DoStuff(f.Create <Item>());
// assert
}
public static long Test(List <int> someList)
{
var recorder = Stopwatch.StartNew();
foreach (int item in someList)
{
SomeService.ServiceOne();
}
recorder.Stop();
return(recorder.ElapsedMilliseconds);
}
public static long Variable(int count)
{
var recorder = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
SomeService.ServiceOne();
}
recorder.Stop();
return(recorder.ElapsedMilliseconds);
}
void TheTest()
{
#region UniformSessionServiceTesting
var session = new TestableUniformSession();
var someService = new SomeService(session);
someService.DoTheThing();
Assert.AreEqual(1, session.SentMessages.Length);
#endregion
}
public MyCustomCheck()
: base("SomeId-StartUp", "SomeCategory")
{
if (SomeService.GetStatus())
{
ReportPass();
}
else
{
ReportFailed("Some service is not available.");
}
}
public void Test1()
{
MockCache _cache = new MockCache();
ISomeService myClass = new SomeService(_cache);
var result = myClass.CreateSomething("doggy", "catty");
Assert.IsType(Type.GetType("System.String"), result.id);
Assert.Equal("doggy", result.firstName);
Assert.Equal("catty", result.lastName);
}
public async Task GivenJobWithConstructorArgs_ItResolvesThemFromTheContainer()
{
// Arrange
var expected = new SomeService();
var host = new TestServiceHost(
componentRegistrations: b => {
b.RegisterInstance(expected).As<SomeService>();
});
host.Initialize();
var job = new JobDescription("test", typeof(TestJobWithService));
var dispatcher = new JobDispatcher(new[] { job }, host.Container);
var invocation = TestHelpers.CreateInvocation(Guid.NewGuid(), "Test", "test", new Dictionary<string, string>());
var context = new InvocationContext(invocation, queue: null);
var slot = new ContextSlot();
TestJobWithService.SetContextSlot(slot);
// Act
await dispatcher.Dispatch(context);
// Assert
Assert.Same(expected, slot.Value);
}
public ClassThatCreatesAServiceInItsContructor()
{
_someService = new SomeService();
}
public void ServiceInjectedViaProperty()
{
var first = new SomeService()
{
Value = 42,
};
var services = new ServiceCollection()
.MakeTransient<ISomeService>()
.AddContributor<ISomeService>((sp, next) => first)
.ChainPrevious<ISomeService, SomeService2>()
.AddInstance<string>("Text");
var configuration = services.BuildApiConfiguration();
var expected = "Text42";
var value = configuration.GetApiService<ISomeService>().Call();
Assert.Equal(expected, value);
value = configuration.GetApiService<ISomeService>().Call();
Assert.Equal(expected, value);
value = configuration.GetApiService<ISomeService>().Call();
Assert.Equal(expected, value);
Assert.NotEqual(
configuration.GetApiService<ISomeService>(),
configuration.GetApiService<ISomeService>());
}
public TestJobWithService(SomeService service)
{
GetContextSlot().Value = service;
}
public SomeService4(SomeService dep1)
: base(dep1)
{
}
public SomeService3(string value, SomeService dep1, SomeService dep2)
{
_value = value;
_service1 = dep1;
_service2 = dep2;
}
public static new IServiceCollection ConfigureApi(Type apiType, IServiceCollection services)
{
var first = new SomeService
{
Value = 42
};
services.MakeTransient<ISomeService>()
.AddService<ISomeService>((sp, next) => first)
.AddService<ISomeService, SomeService2>()
.AddSingleton("Text");
services.AddScoped(apiType, apiType)
.AddScoped(typeof(ApiBase), apiType)
.AddScoped<ApiContext>();
services.TryAddSingleton<ApiConfiguration>();
return services;
}
public SomeService3(string value, SomeService dep1, SomeService dep2)
{
Value = value;
Param2 = dep1;
Param3 = dep2;
}
public SomeService3(SomeService dep1)
{
_value = "4";
_service1 = _service2 = dep1;
}
public SomeService3(SomeService dep1)
{
Value = "4";
Param2 = Param3 = dep1;
}
public SomeOtherService(SomeService someService)
{
this.SomeService = someService;
}
