public async Task GetReportsTest()
{
//Arrange
const string tick = "tick";
var dateTime = new DateTime(2013, 03, 25, 2, 35, 10);
var repositoryFactory = new Mock<IRepositoryFactory>();
var valueConverter = new Mock<ITableValueConverter>();
var mapper = new Mock<IReportMapper>();
var reportEntity = new StandardReportV3Entity() { Tick = tick };
var domainReport = new DomainReport();
var reportEntities = new List<StandardReportV3Entity>() { new StandardReportV3Entity(), reportEntity };
var domainReports = new List<DomainReport>() { domainReport };
var fakeRepository = new FakeRepository<StandardReportV3Entity>(reportEntities);
valueConverter.Setup(m => m.DateTimeToTick(dateTime)).Returns(tick);
repositoryFactory.Setup(m => m.Create<StandardReportV3Entity>(Tables.StandardReportV3)).Returns(fakeRepository);
mapper.Setup(m => m.ReportEntityToDomain(reportEntity)).Returns(domainReport);
var reportService = new StandardReportService(repositoryFactory.Object, valueConverter.Object, mapper.Object);
//Act
var reports = await reportService.GetReports(dateTime);
//Assert
Assert.AreEqual(1, reports.Count);
Assert.AreEqual(domainReports[0], reports[0]);
}
public void UpdateEntity_ShouldUpdateEntity()
{
// arrange
var obj = new Author { Uid = AuthorUid};
var storageObj = new Author { Uid = AuthorUid };
var stub = new FakeRepository(new Dictionary<Type, IEnumerable<IEntity>>
{
{typeof (Author), new[] {new Author {Uid = Guid.NewGuid()}, storageObj}}
});
var updateCommand = new UpdateCommand<Author>();
// act
obj.Name = "foo bar";
obj.About = "sooo some foor";
obj.Company = "rook";
obj.SemanticUid = "foo_bar_rook";
updateCommand.Entity = obj;
updateCommand.Execute(stub);
// assert
Assert.AreEqual(obj.Name, storageObj.Name);
Assert.AreEqual(obj.About, storageObj.About);
Assert.AreEqual(obj.Company, storageObj.Company);
Assert.AreEqual(obj.SemanticUid, storageObj.SemanticUid);
}
public void Setup()
{
subscription = new MailingListSubscription
{
Contact = new Contact()
};
var repository = new FakeRepository(id => subscription);
var repositoryResolver = MockRepository.GenerateStub<IRepositoryResolver>();
repositoryResolver.Stub(r => r.GetRepository(typeof (MailingListSubscription))).Return(repository);
binder = new MailingListSubscriptionBinder(repositoryResolver);
valueProvider = new FakeValueProvider();
context = new ModelBindingContext()
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(MailingListSubscription)),
ModelState = new ModelStateDictionary(),
ValueProvider = valueProvider
};
controllerContext = new ControllerContext
{
HttpContext = MockRepository.GenerateStub<HttpContextBase>()
};
controllerContext.HttpContext.Expect(x => x.Request).Return(MockRepository.GenerateStub<HttpRequestBase>());
controllerContext.HttpContext.Request.Expect(x => x.Form).Return(new NameValueCollection());
}
public void GetRequest_GetAllTest_OneCategoryOnly()
{
FakeRepository<Category> categoryFakeRepository = new FakeRepository<Category>();
FakeRepository<User> userFakeRepository = new FakeRepository<User>();
FakeRepository<Thread> threadFakeRepository = new FakeRepository<Thread>();
string sessionKey = "01234567890123456789012345678901234567890123456789";
Category category = new Category()
{
Name = "Test category"
};
categoryFakeRepository.entities.Add(category);
User user = new User()
{
SessionKey = sessionKey
};
userFakeRepository.Add(user);
CategoriesController categoriesController = new CategoriesController(
categoryFakeRepository, userFakeRepository, threadFakeRepository);
SetupController(categoriesController);
var allCategories = categoriesController.GetAll(sessionKey).ToList<string>();
int expectedCategoryCount = 1;
Assert.AreEqual(expectedCategoryCount, allCategories.Count);
}
public void Add_ValidStudent_CheckIsAdded()
{
var repository = new FakeRepository<Student>();
string firstName = "Nikolay";
string lastName = "Kostov";
var student = MakeSimpleStudent(firstName, lastName);
repository.Entities.Add(student);
var controller = new StudentsController(repository);
var students = controller.Get();
int count = 0;
string firstNameInMemory = null;
foreach (var st in students)
{
count++;
firstNameInMemory = st.FirstName;
}
Assert.IsTrue(count == 1);
Assert.AreEqual(firstName, firstNameInMemory);
}
public void GetAllStudents_WhenThreeStudentsInRepository_ShouldReturnThreeStudents()
{
var repository = new FakeRepository<Student>();
var studentToAdd1 = new Student()
{
FirstName = "Pesho"
};
var studentToAdd2 = new Student()
{
FirstName = "Pesho"
};
var studentToAdd3 = new Student()
{
FirstName = "Pesho"
};
repository.entities.Add(studentToAdd1);
repository.entities.Add(studentToAdd2);
repository.entities.Add(studentToAdd3);
var controller = new StudentsController(repository);
var studentModels = controller.GetAll();
Assert.IsTrue(studentModels.Count() == 3);
}
public void Add_ValidStudent_GetStudentById_CheckIsStudentCorrect()
{
var repository = new FakeRepository<Student>();
string firstName = "Nikolay";
string lastName = "Kostov";
var student = MakeSimpleStudent(firstName, lastName);
repository.Entities.Add(student);
var controller = new StudentsController(repository);
var allStudents = controller.Get();
int studentId = 0;
foreach (var st in allStudents)
{
studentId = st.StudentId;
}
var studentById = controller.Get(studentId);
Assert.AreEqual(studentId, studentById.StudentId);
Assert.AreEqual(firstName, studentById.FirstName);
Assert.AreEqual(lastName, studentById.LastName);
}
public void GetAllStudents_WhenASingleStudentInRepository_ShouldReturnSingleStudent()
{
var repository = new FakeRepository<Student>();
var studentToAdd = new Student()
{
FirstName = "TestName"
};
repository.entities.Add(studentToAdd);
var controller = new StudentController(repository);
var studentModels = controller.GetAll();
int counter = 0;
foreach (var a in studentModels)
{
counter++;
}
Assert.IsTrue(counter == 1);
foreach (var a in studentModels)
{
Assert.AreEqual(studentToAdd.FirstName, a.FirstName);
}
}
public void InitializeRepository()
{
var testData = new List<FakeEntity>();
for (var i = 1; i <= 150; i++)
{
testData.Add(new FakeEntity
{
Id = i,
Name = "Entity " + i,
Description = null,
IsDeleted = i > 100
});
}
IDbSet<FakeEntity> dbSet = TestsMockFactory.CreateDbSet(testData);
var dbContextMock = new Mock<FakeDbContext>();
dbContextMock
.Setup(x => x.FakeEntities)
.Returns(dbSet);
dbContextMock
.Setup(s => s.SaveChanges())
.Throws<DbEntityValidationException>();
repository = new FakeRepository(true, dbContextMock.Object, dbSet,
new InMemoryConfiguration());
}
public void Get_GetAllTest_InvalidSessionKey_NoUserWithSuchSessionKey()
{
FakeRepository<Post> postFakeRepository = new FakeRepository<Post>();
FakeRepository<User> userFakeRepository = new FakeRepository<User>();
FakeRepository<Thread> threadFakeRepository = new FakeRepository<Thread>();
FakeRepository<Vote> voteFakeRepository = new FakeRepository<Vote>();
FakeRepository<Comment> commentFakeRepository = new FakeRepository<Comment>();
User user = new User()
{
AuthCode = "0123456789012345678901234567890123456789",
Username = "******",
Nickname = "TestNickname",
SessionKey = "0SuGqVGqRwitYtijDvHlVfHGotklitbwHdYFkgwIRcIQjRASPQ"
};
userFakeRepository.entities.Add(user);
PostsController threadsController = new PostsController(
postFakeRepository, userFakeRepository, threadFakeRepository, voteFakeRepository, commentFakeRepository);
SetupController(threadsController);
threadsController.GetAll("1InvalidSessionKeyvHlVfHGotklitbwHdYFkgwIRcIQjRAPQ");
}
public void InitRepositoryParams()
{
var testData = new List<FakeEntity>();
for (var i = 1; i <= 150; i++)
{
testData.Add(new FakeEntity
{
Id = i,
Name = "Entity " + i,
Description = null,
IsDeleted = i > 100
});
}
IQueryable<FakeEntity> fakeList = testData.AsQueryable();
IDbSet<FakeEntity> dbSetMock = TestsMockFactory.CreateDbSet(fakeList);
var dbContextMock = new Mock<FakeDbContext>();
dbContextMock
.Setup(x => x.FakeEntities)
.Returns(dbSetMock);
repository = new FakeRepository(false, dbContextMock.Object, dbSetMock,
new InMemoryConfiguration());
}
public void GetAll_WhenValid_ShouldReturnBugsCollection()
{
//arrange
FakeRepository<Bug> fakeRepo = new FakeRepository<Bug>();
var bugs = new List<Bug>()
{
new Bug()
{
Text = "TEST NEW BUG 1"
},
new Bug()
{
Text = "TEST NEW BUG 2"
},
new Bug()
{
Text = "TEST NEW BUG 3"
}
};
fakeRepo.Entities = bugs;
var controller = new BugsController(fakeRepo as IRepository<Bug>);
//act
var result = controller.GetAll();
//assert
CollectionAssert.AreEquivalent(bugs, result.ToList<Bug>());
}
public void Setup()
{
product = new Product
{
Reviews =
{
new Review(),
new Review()
}
};
productRepository = new FakeRepository<Product>(id =>
{
product.Id = id;
return product;
});
reviewRepository = MockRepositoryBuilder.CreateReviewRepository();
commentRepository = MockRepository.GenerateStub<IRepository<IComment>>();
var comments = new List<IComment>
{
new Comment{ Approved = true },
new Comment{ Approved = false },
new Review{ Approved = true },
new Comment{ Approved = true }
}.AsQueryable();
commentRepository.Stub(r => r.GetAll()).Return(comments);
controller = new ReviewsController(reviewRepository, productRepository, commentRepository);
}
public void GetAllStudents_WhenNoStudentsInRepository_ShouldReturnNoStudents()
{
var repository = new FakeRepository<Student>();
var controller = new StudentsController(repository);
var studentModels = controller.GetAll();
Assert.IsTrue(studentModels.Count() == 0);
}
public void SetUp()
{
var fakeDbSet = new FakeRepository<Student>();
fakeBackingCollection = fakeDbSet.BackingCollection;
unitOfWorkWithFake = new Mock<IStudentUnitOfWork>();
unitOfWorkWithFake.SetupGet(c => c.Students).Returns(fakeDbSet);
serviceWithFake = new StudentService(unitOfWorkWithFake.Object);
}
public override void SetUp()
{
base.SetUp();
UrlParser inner = TestSupport.Setup(persister, wrapper, host);
parser = new CachingUrlParserDecorator(inner, persister, wrapper, new CacheWrapper(persister, wrapper, new DatabaseSection()));
CreateDefaultStructure();
repository = (FakeRepository<ContentItem>) persister.Repository;
}
public ServiceSchool()
{
repository = new FakeRepository();
foreach (var stud in TestingTools.POCOFactory.GenerateStudents(100))
{
repository.Insert(stud);
}
}
public void GetAllTransactionData()
{
var repository = new FakeRepository();
var validator = new TaxValidator();
var taxCalculationBll = new TaxCalculatorBll.TaxCalculatorBll(repository, validator);
var result = taxCalculationBll.GetAll();
OutputValid("Transaction data", result);
}
public void Initialize()
{
_mockDbContext = new Mock<IDbContext>();
_fakeDbSet = FakeDbSetBuilder.New<FakeObject>().Build(t => t.Id);
_mockDbContext.Setup(t => t.FindAll<FakeObject>()).Returns(_fakeDbSet);
_unitOfWork = new EFUnitOfWork(_mockDbContext.Object);
_repository = new FakeRepository(_mockDbContext.Object, _unitOfWork);
}
public void RepositoryBase_Constructor_Sets_CacheKey_Empty_If_Not_Cacheable()
{
//Arrange
//Act
var repo = new FakeRepository <Dog>(_mockCache.Object);
//Assert
Assert.AreEqual(String.Empty, repo.CacheKey);
}
public void RepositoryBase_Constructor_Sets_Scope_Empty_If_Cacheable_And_Not_Scoped()
{
//Arrange
//Act
var repo = new FakeRepository <CacheableDog>(_mockCache.Object);
//Assert
Assert.AreEqual(String.Empty, repo.Scope);
}
public void RepositoryBase_Constructor_Sets_Scope_If_Cacheable_And_Scoped()
{
//Arrange
//Act
var repo = new FakeRepository <CacheableCat>(_mockCache.Object);
//Assert
Assert.AreEqual(TestConstants.CACHE_ScopeModule, repo.Scope);
}
public void RepositoryBase_Constructor_Sets_IsScoped_True_If_Cacheable_And_Scoped()
{
//Arrange
//Act
var repo = new FakeRepository <CacheableCat>(_mockCache.Object);
//Assert
Assert.IsTrue(repo.IsScoped);
}
public void adopting_puppy_registers_the_new_owner()
{
FakeRepository fakeRepo = new FakeRepository();
AdoptPuppyUseCase uc = new AdoptPuppyUseCase(fakeRepo);
uc.Execute("Spike", "Marc", () => {});
Assert.That(fakeRepo.addWasCalled, Is.True);
Assert.That(fakeRepo.observedAddName, Is.EqualTo("Marc"));
}
public void GetEntitiesSucceeds()
{
var mockedContext = new Mock <DbContext>();
mockedContext.Setup(context => context.Set <FakeEntity>())
.Returns(new Mock <DbSet <FakeEntity> >().Object);
var repository = new FakeRepository(mockedContext.Object);
repository.Entities.Should().NotBeNull();
mockedContext.Verify(context => context.Set <FakeEntity>(), Times.Once);
}
public void RepositoryBase_Constructor_Sets_CacheKey_If_Cacheable()
{
//Arrange
//Act
var repo = new FakeRepository<CacheableDog>(_mockCache.Object);
//Assert
var baseRepo = repo as RepositoryBase<CacheableDog>;
Assert.AreEqual(TestConstants.CACHE_DogsKey, Util.GetPrivateProperty<RepositoryBase<CacheableDog>, string>(baseRepo, "CacheKey"));
}
public void Repository_can_be_created_from_simple_list()
{
Product product = new Product();
List<Product> products = new List<Product> { product };
IRepository<Product> repository = new FakeRepository<Product>(products);
repository.Fetch(x => x.Category);
Assert.That(repository.ToList(), Is.Not.Empty);
}
public void Setup()
{
_controller = new FoodItemController(_mapper, _unitOfWork);
_foodItemRepository = _unitOfWork.FoodItemRepository as FakeRepository<Data.Models.FoodItem>;
_foodItem = _mapper.Map<FoodItem>(_foodItemRepository.Insert(new Data.Models.FoodItem()
{
BarCode = new Data.Models.BarCode { Identifier = "123", Type = Data.Models.BarCodeType.Regular },
Name = "Juice",
ShelfLifeDays = 4
}));
}
public Search()
{
var fakeRepository = new FakeRepository();
SpeakerFactory.Create(fakeRepository);
SpeakerFactory.Create(fakeRepository, name: "Josh");
SpeakerFactory.Create(fakeRepository, name: "Joseph");
SpeakerFactory.Create(fakeRepository, name: "Bill");
_speakerService = new SpeakerService(fakeRepository);
}
public void SetUp()
{
productCopyService = MockRepository.GenerateStub <IProductCopyService>();
productRepository = new FakeRepository <Product>();
unitOfWork = MockRepository.GenerateStub <IUnitOfWorkManager>();
productCopyController = new ProductCopyController(
productCopyService,
productRepository,
unitOfWork);
}
public async Task GivenApplicationUserIsNullAndActivityHasValidRolesWhenIsAuthorizedIsCalledThenExceptionIsThrown(int numberOfRoles)
{
var fakeRepository = A.Fake <IGetRepository <IApplicationUser> >();
A.CallTo(() => FakeRepository.GetItemAsync(A <string> ._)).Returns(Task.FromResult <IApplicationUser>(null));
A.CallTo(() => FakeActivity.ValidRoles).Returns(A.CollectionOfFake <IRole>(numberOfRoles));
var authorizer = new ActivityAuthorizer(fakeRepository);
Assert.False(await authorizer.IsAuthorized(FakeActivity));
}
public void Add_ValidStudent_ResponseShouldBeOkAndContentNotNull()
{
var repository = new FakeRepository<Student>();
var server = new InMemoryHttpServer<Student>("http://localhost/", repository);
var response = server.CreateGetRequest("api/students");
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(response.Content);
}
public void adopting_puppy_makes_it_unavailable()
{
FakeRepository fakeRepo = new FakeRepository();
AdoptPuppyUseCase uc = new AdoptPuppyUseCase(fakeRepo);
uc.Execute("Spike", "Marc", () => {});
Assert.That(fakeRepo.removeWasCalled, Is.True);
Assert.That(fakeRepo.observedRemoveName, Is.EqualTo("Spike"));
}
/// <summary>
/// Точка входа в программу.
/// </summary>
/// <param name="args">Аргументы командной строки.</param>
private static void Main(string[] args)
{
IRepository repo = new FakeRepository();
IDocumentComponent doc = repo.Load();
Console.WriteLine(doc.Description);
IExporter exporter = new PackingDecorator(new EncryptingDecorator(new LocalStorageFakeExporter()));
exporter.Export(doc, DestinationDirectoryPath);
}
public void RepositoryBase_Constructor_Sets_CacheArgs_If_Cacheable()
{
//Arrange
//Act
var repo = new FakeRepository<CacheableDog>();
//Assert
var baseRepo = repo as RepositoryBase<CacheableDog>;
Assert.IsNotNull(Util.GetPrivateMember<RepositoryBase<CacheableDog>, CacheItemArgs>(baseRepo, "CacheArgs"));
}
/// <summary>
/// Uses whitelist approach to validate input against organizations found in FakeRepository.
/// </summary>
/// <param name="organization"></param>
/// <returns></returns>
public static bool ValidateOrganization(string organization)
{
var organizations = new List <string>();
using (var repository = new FakeRepository())
{
organizations = repository.GetOrganizations();
}
return(organizations.Contains(organization));
}
public void SetUp()
{
DomainEvent.TurnOff();
productCategoryOrderableService = MockRepository.GenerateStub<IOrderableService<ProductCategory>>();
productRepository = new FakeRepository<Product>();
productCopyService = new ProductCopyService(productCategoryOrderableService, productRepository);
originalCategory = new Category();
originalProduct = CreateProduct(originalCategory);
}
public void PostProductTest(Product product, FakeRepository <Product, int> repository)
{
var controller = new ProductsController(repository);
var postActionResult = controller.PostProduct(product);
var postResult = postActionResult as CreatedAtRouteNegotiatedContentResult <Product>;
Assert.NotNull(postResult);
Assert.Equal(product, postResult.Content);
Assert.NotNull(repository.GetById(product.Id));
}
public void Given_GetTransactions_When_condition_Should_expect()
{
// Given
var transactionRepository = new FakeRepository <POSOrder>(new[] { GetSeedTransaction() });
var service = new POSOrderService(transactionRepository, new TransactionValidator());
// When
var transactions = service.GetTransactions();
// Then
Assert.NotEmpty(transactions);
}
public void FakeProductProductRepository_FindAll_ReturnsListOfProductWithCorrectLength()
{
// Arrange
IRepository<Product> repo = new FakeRepository<Product>(ObjectMother.Test1Product);
// Act
var products = repo.FindAll();
// Assert
Assert.AreEqual(1, products.Count());
}
public void SetUp()
{
DomainEvent.TurnOff();
productCategoryOrderableService = MockRepository.GenerateStub <IOrderableService <ProductCategory> >();
productRepository = new FakeRepository <Product>();
productCopyService = new ProductCopyService(productCategoryOrderableService, productRepository);
originalCategory = new Category();
originalProduct = CreateProduct(originalCategory);
}
public void Init(bool seed = true)
{
Localities = new Repository <Locality>();
Classifiers = new FakeRepository <Classifier>();
Companies = new FakeRepository <Company>();
if (seed)
{
BuildTestData();
}
}
public void Fetching_provider_should_be_mockable()
{
Product product = new Product { Price = 10 };
IRepository<Product> products = new FakeRepository<Product> { product };
ProductsCalculator calculator = new ProductsCalculator(products);
double totalPrice = calculator.GetTotalPrice();
Assert.That(totalPrice, Is.EqualTo(10));
}
public void PutProductTest(Product product, FakeRepository <Product, int> repository)
{
var controller = new ProductsController(repository);
var putActionResult = controller.PutProduct(product.Id, product);
var putResult = putActionResult as StatusCodeResult;
Assert.NotNull(putResult);
Assert.Equal(HttpStatusCode.NoContent, putResult.StatusCode);
Assert.NotNull(repository.GetById(product.Id));
}
public void RepositoryBase_Constructor_Sets_CacheKey_Empty_If_Not_Cacheable()
{
//Arrange
//Act
var repo = new FakeRepository<Dog>(_mockCache.Object);
//Assert
var baseRepo = repo as RepositoryBase<Dog>;
Assert.AreEqual(String.Empty,Util.GetPrivateProperty<RepositoryBase<Dog>, string>(baseRepo, "CacheKey"));
}
public async Task ShouldNotCommitOnEndWithException()
{
var repo = new FakeRepository();
Inject <IRepository <FakeEntity> >(repo);
Sut.For <FakeEntity>();
await(Sut as Aggregates.UnitOfWork.IUnitOfWork).End(new Exception()).ConfigureAwait(false);
repo.CommitCalled.Should().BeFalse();
}
public void RepositoryBase_Constructor_Sets_IsCacheable_True_If_Cacheable()
{
//Arrange
//Act
var repo = new FakeRepository<CacheableDog>(_mockCache.Object);
//Assert
var baseRepo = repo as RepositoryBase<CacheableDog>;
Assert.IsTrue(Util.GetPrivateProperty<RepositoryBase<CacheableDog>, bool>(baseRepo, "IsCacheable"));
}
public void GetProductsTest(Product product, FakeRepository <Product, int> repository)
{
var controller = new ProductsController(repository);
repository.Create(product);
IEnumerable <Product> found = controller.GetProducts();
Assert.NotNull(found);
Assert.NotEmpty(found);
}
public void SetUp()
{
productCopyService = MockRepository.GenerateStub<IProductCopyService>();
productRepository = new FakeRepository<Product>();
unitOfWork = MockRepository.GenerateStub<IUnitOfWorkManager>();
productCopyController = new ProductCopyController(
productCopyService,
productRepository,
unitOfWork);
}
public void adopting_a_puppy_generates_notification_on_completion()
{
FakeRepository fakeRepo = new FakeRepository();
bool notificationReceived = false;
AdoptPuppyUseCase uc = new AdoptPuppyUseCase(fakeRepo);
uc.Execute("Spike", "Marc", () => notificationReceived = true);
Assert.That(notificationReceived, Is.True);
}
public void FakeProductProductRepository_FindByID_DoesNotReturnProductIfNotPresent()
{
// Arrange
IRepository <Product> repo = new FakeRepository <Product>(ObjectMother.Test1Product);
// Act
var product = repo.FindByID(2);
// Assert
Assert.IsNull(product);
}
public void FakeProductProductRepository_FindAll_ReturnsListOfProductWithCorrectLength()
{
// Arrange
IRepository <Product> repo = new FakeRepository <Product>(ObjectMother.Test1Product);
// Act
var products = repo.FindAll();
// Assert
Assert.AreEqual(1, products.Count());
}
public void ItAcceptsIRepository()
{
// Arrange
var fakeRepository = new FakeRepository();
// Act
var service = new SpeakerService(fakeRepository);
// Assert
Assert.NotNull(service);
}
/// <summary>
/// Get items from repository
/// </summary>
/// <returns></returns>
private List <ItemModelDTO> GetItems()
{
var items = new List <ItemModelDTO>();
using (var repo = new FakeRepository())
{
items = repo.GetItems();
}
return(items);
}
public void FakeProductProductRepository_FindAll_ReturnsListOfProduct()
{
// Arrange
IRepository <Product> repo = new FakeRepository <Product>(ObjectMother.Test1Product);
// Act
var products = repo.FindAll();
// Assert
Assert.AreEqual(1, products.Count());
Assert.AreEqual(products.FirstOrDefault().GetType(), typeof(Product));
}
public void RepositoryBase_Constructor_Sets_Scope_Empty_If_Cacheable_And_Not_Scoped()
{
// Arrange
// Act
var repo = new FakeRepository <CacheableDog>();
// Assert
var baseRepo = repo as RepositoryBase <CacheableDog>;
Assert.AreEqual(string.Empty, Util.GetPrivateMember <RepositoryBase <CacheableDog>, string>(baseRepo, "Scope"));
}
public void RepositoryBase_Constructor_Sets_IsCacheable_True_If_Cacheable()
{
// Arrange
// Act
var repo = new FakeRepository <CacheableDog>();
// Assert
var baseRepo = repo as RepositoryBase <CacheableDog>;
Assert.IsTrue(Util.GetPrivateMember <RepositoryBase <CacheableDog>, bool>(baseRepo, "IsCacheable"));
}
public void RepositoryBase_Constructor_Sets_CacheArgs_If_Cacheable()
{
// Arrange
// Act
var repo = new FakeRepository <CacheableDog>();
// Assert
var baseRepo = repo as RepositoryBase <CacheableDog>;
Assert.IsNotNull(Util.GetPrivateMember <RepositoryBase <CacheableDog>, CacheItemArgs>(baseRepo, "CacheArgs"));
}
public void RepositoryBase_Initialize_Sets_IsCacheable_False_If_Not_Cacheable()
{
// Arrange
// Act
var repo = new FakeRepository <Dog>();
// Assert
var baseRepo = repo as RepositoryBase <Dog>;
Assert.IsFalse(Util.GetPrivateMember <RepositoryBase <Dog>, bool>(baseRepo, "IsCacheable"));
}
public void RepositoryBase_Constructor_Sets_Scope_If_Cacheable_And_Scoped()
{
// Arrange
// Act
var repo = new FakeRepository <CacheableCat>();
// Assert
var baseRepo = repo as RepositoryBase <CacheableCat>;
Assert.AreEqual(Constants.CACHE_ScopeModule, Util.GetPrivateMember <RepositoryBase <CacheableCat>, string>(baseRepo, "Scope"));
}
