public void GetCreatorCanReturnCreatorInsideAnotherAppDomain()
 {
     using (MockDomain otherDomain = new MockDomain())
     {
         IPluginCreator tested = PluginCreator.GetCreator(otherDomain);
         Assert.IsNotNull(tested);
     }
 }
 public void GetCreatorShouldReturnSameInstanceForSameDomain()
 {
     using (MockDomain otherDomain = new MockDomain())
     {
         IPluginCreator first  = PluginCreator.GetCreator(otherDomain);
         IPluginCreator tested = PluginCreator.GetCreator(otherDomain);
         Assert.AreSame(first, tested);
     }
 }
 public void GetCreatorShouldReturnDifferentInstanceForDifferentDomain()
 {
     using (MockDomain domain1 = new MockDomain())
         using (MockDomain domain2 = new MockDomain())
         {
             IPluginCreator tested1 = PluginCreator.GetCreator(domain1);
             IPluginCreator tested2 = PluginCreator.GetCreator(domain2);
             Assert.AreNotSame(tested1, tested2);
         }
 }
Example #4
0
        public void ListAllTest()
        {
            var context = new MockContext <IDomain>();

            context.Arrange(m => m.List(The <DomainQuery> .Is(q => q.Size == 100), null)).Returns(new Domain[1]);
            var domain = new MockDomain(context);
            var items  = domain.ListAll();

            Assert.Equal(1, items.Count());
        }
Example #5
0
        public async void GetOrCreateAsyncTest2()
        {
            var context = new MockContext <IDomain>();

            context.Arrange(m => m.List(The <DomainQuery> .IsAnyValue, null)).Returns(new Domain[0]);
            context.Arrange(m => m.CreateAsync(The <CreateDomainData> .Is(q => q.Name == "domain"), null)).Returns(Task.FromResult("domainId3"));
            var domain = new MockDomain(context);
            var id     = await domain.GetOrCreateAsync("domain");

            Assert.Equal("domainId3", id);
        }
 public void CreateShouldResolveMissingAssemblies()
 {
     using (MockDomain domain = new MockDomain())
     {
         MockAssemblyRepository repository = new MockAssemblyRepository();
         IPluginCreator         tested     = PluginCreator.GetCreator(domain);
         PluginDescriptor       descriptor = MockPluginDescriptor.For <MockPlugin1>();
         object instance = tested.Create(descriptor, repository, null);
         Assert.IsNotNull(instance);
         Assert.IsTrue(repository.Fetched.Keys.Contains(typeof(MockPlugin1).Assembly.FullName));
     }
 }
 public void ShouldLogInfoMessageWhenPluginIsCreated()
 {
     using (MockDomain domain = new MockDomain())
     {
         MockAssemblyRepository repository = new MockAssemblyRepository();
         var     creator    = PluginCreator.GetCreator(domain);
         MockLog mocklog    = new MockLog(creator as ILogWriter);
         var     descriptor = MockPluginDescriptor.For <MockPlugin1>();
         creator.Create(descriptor, repository, null);
         Assert.IsTrue(mocklog.Any(x => x.Level == MockLog.Level.Info && x.Message.Contains(typeof(MockPlugin1).FullName)));
     }
 }
 public void ShouldLogInfoEventWithDomainNameOnNewPluginCreator()
 {
     using (MockDomain domain = new MockDomain())
     {
         MockAssemblyRepository repository = new MockAssemblyRepository();
         MockLog mocklog        = new MockLog(typeof(PluginCreator));
         var     mockLogFactory = new Mock <ILoggerFactory>();
         mockLogFactory.Setup(x => x.GetLog(typeof(PluginCreator).FullName)).Returns(mocklog);
         PluginCreator.GetCreator(domain, mockLogFactory.Object);
         Assert.IsTrue(mocklog.Any(x => x.Level == MockLog.Level.Info && x.Message.Contains(domain.Domain.FriendlyName)));
     }
 }
        public void CreateShouldLogCatchedExceptionAsError()
        {
            using (MockDomain domain = new MockDomain())
            {
                MockAssemblyRepository repository = new MockAssemblyRepository();
                QualifiedName          fakeName   = new QualifiedName(
                    typeof(string).FullName.Replace("mscorlib", "NonExistingAssemblyName"),
                    typeof(string).Assembly.FullName.Replace("mscorlib", "NonExistingAssemblyName"));

                IPluginCreator   tested     = PluginCreator.GetCreator(domain);
                MockLog          mocklog    = new MockLog((ILogWriter)tested);
                PluginDescriptor descriptor = MockPluginDescriptor.For(fakeName);
                Exception        ex         = DoAssert.Throws <PluginException>(() => tested.Create(descriptor, repository, null));
                Assert.IsTrue(mocklog.Any(x => x.Level == MockLog.Level.Error && x.Message.Contains(ex.Message)));
            }
        }
Example #10
0
        public async void GetOrCreateAsyncTest()
        {
            var context = new MockContext <IDomain>();

            context.Arrange(m => m.List(The <DomainQuery> .IsAnyValue, null)).Returns(new [] {
                new Domain
                {
                    Id   = "domainId2",
                    Name = "domain"
                }
            });
            var domain = new MockDomain(context);
            var id     = await domain.GetOrCreateAsync("domain");

            Assert.Equal("domainId2", id);
        }
Example #11
0
        public void GetByNameTest()
        {
            var context = new MockContext <IDomain>();

            context.Arrange(m => m.List(The <DomainQuery> .Is(q => q.Size == 100), null)).Returns(new [] {
                new Domain
                {
                    Id   = "domainId1",
                    Name = "domain"
                }
            });
            var domain = new MockDomain(context);
            var item   = domain.GetByName("domain");

            Assert.Equal("domainId1", item.Id);
        }
        public void CreateShouldThrowOnUnresolvedAssembly()
        {
            using (MockDomain domain = new MockDomain())
            {
                MockAssemblyRepository repository = new MockAssemblyRepository();
                IPluginCreator         tested     = PluginCreator.GetCreator(domain);
                QualifiedName          fakeName   = new QualifiedName(
                    typeof(string).FullName.Replace("mscorlib", "NonExistingAssemblyName"),
                    typeof(string).Assembly.FullName.Replace("mscorlib", "NonExistingAssemblyName"));

                PluginDescriptor descriptor = MockPluginDescriptor.For(fakeName);

                PluginException ex = DoAssert.Throws <PluginException>(() => tested.Create(descriptor, repository, null));
                Assert.IsNotNull(ex.InnerException);
                Assert.IsInstanceOfType(ex.InnerException, typeof(FileNotFoundException));
            }
        }