public void ImplicitOperatorFromItem_NullItem_ReturnsNull()
        {
            // arrange, act
            ScribanMailActionItem item = (Item)null;

            // assert
            Assert.That(item, Is.Null);
        }
        public void ImplicitOperatorFromItem_ValidItem_ReturnsScribanMailActionItem()
        {
            // arrange
            var item = ItemFactory.CreateItem().Object;

            // act
            ScribanMailActionItem sut = item;

            // assert
            Assert.That(sut.InnerItem, Is.EqualTo(item));
        }
        public void Properties_ItemDoesNotHaveField_ReturnsEmptyString(Func <ScribanMailActionItem, string> propertyAccessor)
        {
            // arrange
            var item = ItemFactory.CreateItem().Object;
            var sut  = new ScribanMailActionItem(item);

            // act
            var result = propertyAccessor(sut);

            // assert
            Assert.That(result, Is.Empty);
        }
        public void ImplicitOperatorFromScribanMailActionItem_ValidItem_ReturnsItem()
        {
            // arrange
            var item = ItemFactory.CreateItem().Object;
            var sut  = new ScribanMailActionItem(item);

            // act
            Item returnedItem = sut;

            // assert
            Assert.That(returnedItem, Is.EqualTo(item));
        }
Exemple #5
0
        public virtual void Process(WorkflowPipelineArgs args)
        {
            ScribanMailActionItem actionItem = args.ProcessorItem.InnerItem;
            var mailTo = actionItem.To;

            if (string.IsNullOrWhiteSpace(mailTo))
            {
                Log.Error(GetType().FullName + " cannot be invoked with an empty 'To' field.", this);
                return;
            }

            var mailFrom = actionItem.From;

            if (string.IsNullOrWhiteSpace(mailFrom))
            {
                Log.Error(GetType().FullName + " cannot be invoked with an empty 'From' field.", this);
                return;
            }

            var mailSubject = actionItem.Subject;
            var mailBody    = actionItem.Message;

            var model = CreateModel(args);

            try
            {
                mailTo      = ProcessScribanTemplate(mailTo, model);
                mailFrom    = ProcessScribanTemplate(mailFrom, model);
                mailSubject = ProcessScribanTemplate(mailSubject, model);
                mailBody    = ProcessScribanTemplate(mailBody, model);
            }
            catch (Exception ex)
            {
                Log.Error("An error occurred whilst rendering a Scriban template in " + GetType().FullName, ex, this);
                return;
            }

            try
            {
                var message = new MailMessage(mailFrom, mailTo, mailSubject, mailBody);
                message.IsBodyHtml = true;

                using (var smtpClient = SmtpClientFactory.Invoke())
                {
                    smtpClient.Send(message);
                }
            }
            catch (Exception ex)
            {
                Log.Error("Exception while sending workflow email", ex, this);
                args.AbortPipeline();
            }
        }
        public void Properties_ItemHasField_ReturnsFieldValue(string fieldName, string fieldValue, Func <ScribanMailActionItem, string> propertyAccessor)
        {
            // arrange
            var itemMock = ItemFactory.CreateItem();

            ItemFactory.SetIndexerField(itemMock, fieldName, fieldValue);

            var item = itemMock.Object;
            var sut  = new ScribanMailActionItem(item);

            // act
            var result = propertyAccessor(sut);

            // assert
            Assert.That(result, Is.EqualTo(fieldValue));
        }