Exemple #1
0
        public void Test_PluginRouter_Under_Parallel_Load()
        {
            string configPath = GetSettingsPath("TestReceiverPlugin.xml");
            var    settings   = SmtpAgentSettings.LoadSettings(configPath);

            settings.InternalMessage.PickupFolder = TestPickupFolder;

            //
            // Create the SmtpAgent.  This is the adapter between IIS SMTP and the DirectAgent (security and trust code)
            //
            m_agent = SmtpAgentFactory.Create(settings);
            CleanMessages(m_agent.Settings);

            //
            // Mocks use the AddressMemoryStore
            //
            AddressMemoryStore.Clear();
            AddressMemoryStore.AddRange(new Address[]
            {
                new Address {
                    EmailAddress = "*****@*****.**", Status = EntityStatus.Enabled, Type = "STUB"
                }
            });

            var mockAddressClientSettings = MockAddressClientSettings();

            m_agent.Settings.AddressManager = mockAddressClientSettings.Object;


            DirectAgent agentA = new DirectAgent("redmond.hsgincubator.com");

            Parallel.For(0, 50, new ParallelOptions {
                MaxDegreeOfParallelism = 10
            }, i =>
            {
                var message = string.Format(TestMessageLoad, Guid.NewGuid().ToString("N"), i);

                //
                // Prep and encrypted message.
                //
                var outMessage = agentA.ProcessOutgoing(message).SerializeMessage();
                var cdoMessage = new CDOSmtpMessage(base.LoadMessage(outMessage));

                m_agent.ProcessMessage(cdoMessage);
            });


            Assert.Equal(49, Directory.GetFiles(TestIncomingFolder).Length);
            Assert.Equal(1, Directory.GetFiles(TestPickupFolder).Length);
        }
Exemple #2
0
        public void TestPrivateKeyLookupFailure()
        {
            string fileName    = "simple.eml";
            string messageText = m_tester.ReadMessageText(fileName);

            Message message = MailParser.ParseMessage(messageText);

            message.ToValue = "*****@*****.**";  // this should force a key lookup failure
            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => m_tester.AgentA.ProcessOutgoing(new OutgoingMessage(message)),
                AgentError.NoTrustedRecipients
                );

            DirectAgent badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentA.Domains.Domains.ToArray()),
                                                   new NullResolver(), // returns null private certs
                                                   m_tester.AgentA.PublicCertResolver,
                                                   m_tester.AgentA.TrustAnchors);

            message = MailParser.ParseMessage(messageText);
            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => badAgent.ProcessOutgoing(new OutgoingMessage(message)),
                AgentError.CouldNotResolvePrivateKey
                );

            OutgoingMessage outgoing = m_tester.AgentA.ProcessOutgoing(messageText);

            badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentB.Domains.Domains.ToArray()),
                                       new NullResolver(),            // returns null private certs
                                       m_tester.AgentB.PublicCertResolver,
                                       m_tester.AgentB.TrustAnchors);

            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => badAgent.ProcessIncoming(outgoing.SerializeMessage()),
                AgentError.CouldNotResolvePrivateKey
                );

            badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentB.Domains.Domains.ToArray()),
                                       new NullResolver(true),            // returns empty private cert collections
                                       m_tester.AgentB.PublicCertResolver,
                                       m_tester.AgentB.TrustAnchors);

            AgentTester.CheckErrorCode <AgentException, AgentError>(
                () => badAgent.ProcessIncoming(outgoing.SerializeMessage()),
                AgentError.CouldNotResolvePrivateKey
                );
        }
 public OutgoingMessage ProcessOutgoing(string messageText)
 {
     return(m_agentA.ProcessOutgoing(messageText));
 }
Exemple #4
0
        public void TestPrivateKeyLookupFailure()
        {
            string fileName = "simple.eml";            
            string messageText = m_tester.ReadMessageText(fileName);
            
            Message message = MailParser.ParseMessage(messageText);
            message.ToValue = "*****@*****.**";  // this should force a key lookup failure            
            AgentTester.CheckErrorCode<AgentException, AgentError>(
                () => m_tester.AgentA.ProcessOutgoing(new OutgoingMessage(message)),
                AgentError.NoTrustedRecipients
            );

            DirectAgent badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentA.Domains.Domains.ToArray()),
                                                 new NullResolver(),  // returns null private certs
                                                 m_tester.AgentA.PublicCertResolver,
                                                 m_tester.AgentA.TrustAnchors);

            message = MailParser.ParseMessage(messageText);
            AgentTester.CheckErrorCode<AgentException, AgentError>(
                () => badAgent.ProcessOutgoing(new OutgoingMessage(message)),
                AgentError.CouldNotResolvePrivateKey
            );
            
            OutgoingMessage outgoing = m_tester.AgentA.ProcessOutgoing(messageText);

            badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentB.Domains.Domains.ToArray()),
                                                 new NullResolver(),  // returns null private certs
                                                 m_tester.AgentB.PublicCertResolver,
                                                 m_tester.AgentB.TrustAnchors);

            AgentTester.CheckErrorCode<AgentException, AgentError>(
                () => badAgent.ProcessIncoming(outgoing.SerializeMessage()),
                AgentError.CouldNotResolvePrivateKey
            );

            badAgent = new DirectAgent(new StaticDomainResolver(m_tester.AgentB.Domains.Domains.ToArray()),
                                                 new NullResolver(true),  // returns empty private cert collections
                                                 m_tester.AgentB.PublicCertResolver,
                                                 m_tester.AgentB.TrustAnchors);

            AgentTester.CheckErrorCode<AgentException, AgentError>(
                () => badAgent.ProcessIncoming(outgoing.SerializeMessage()),
                AgentError.CouldNotResolvePrivateKey
            );
        }