carterdte_smtp_filter 0.0.3

data/test/fixtures/resultado_revision_sii.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<RESULTADO_ENVIO>
+ <IDENTIFICACION>
+  <RUTEMISOR>81137900-K</RUTEMISOR>
+  <RUTENVIA>11862736-9</RUTENVIA>
+  <TRACKID>1031250770</TRACKID>
+  <TMSTRECEPCION>09/05/2015 12:18:50</TMSTRECEPCION>
+  <ESTADO>EPR - Envio Procesado</ESTADO>
+ </IDENTIFICACION>
+ <ESTADISTICA>
+  <SUBTOTAL>
+   <TIPODOC>33</TIPODOC>
+   <INFORMADO>1</INFORMADO>
+   <ACEPTA>1</ACEPTA>
+  </SUBTOTAL>
+ </ESTADISTICA>
+</RESULTADO_ENVIO>

data/test/test_api_client.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class TestApiClient < Minitest::Test
+  
+
+  def setup
+    CarterdteSmtpFilter::Config.parse("./test/fixtures/config.yml")
+    @api_host = CarterdteSmtpFilter::Config::api_host
+    @api_url = "http://#{@api_host}"
+    stub_request(:any, /#{@api_host}/).to_rack(FakeApi)
+  end
+  
+  def test_push_should_return_false_if_message_is_not_json
+    response = CarterdteSmtpFilter::ApiClient.push "hola"
+    assert(!response, "Failure message.")
+  end
+    
+  def test_check_fake_api_response
+    user = CarterdteSmtpFilter::Config::api_user.gsub(/@/,"%40")
+    response = RestClient.get "http://#{user}:#{CarterdteSmtpFilter::Config::api_password}@#{@api_host}/api/v1/"
+    assert_equal("{api_version: 1}", response)
+  end
+  
+  def test_post_should_workout_unauthorized
+    response = CarterdteSmtpFilter::ApiClient.post({url: "#{@api_url}/api/v1/denied" })
+    assert(!response, "Failure message.")
+  end
+  
+  def test_post_should_workout_application_error
+    response = CarterdteSmtpFilter::ApiClient.post({url: "#{@api_url}/api/v1/app_error" })
+    assert(!response, "Failure message.")
+  end
+  
+  def test_post_should_return_json
+    hash = {dte_type: 33, msg_type: "envio"}
+    json = JSON.generate hash
+    response = CarterdteSmtpFilter::ApiClient.post({payload: json})
+    new_hash = JSON.parse response
+    assert_equal("123456", new_hash["id"])
+    assert_equal(hash[:dte_type], new_hash["dte_type"])
+  end
+    
+end

data/test/test_config.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class TestConfig < Minitest::Test
+  
+  def test_should_raise_not_file_if_file_not_exists
+    assert_raises(Errno::ENOENT) { CarterdteSmtpFilter::Config.parse("/tmp/file") }
+  end
+  
+  def test_should_return_config_values
+    CarterdteSmtpFilter::Config.parse("./test/fixtures/config.yml")
+    assert_equal("127.0.0.1", CarterdteSmtpFilter::Config::bind_address)
+    assert_equal("127.0.0.1", CarterdteSmtpFilter::Config::return_host)
+    assert_equal("30025", CarterdteSmtpFilter::Config::return_port)
+    assert_equal("pbruna@example.com", CarterdteSmtpFilter::Config::api_user)
+    assert_equal("123456", CarterdteSmtpFilter::Config::api_password)
+    assert_equal("api.dte.zboxapp.com", CarterdteSmtpFilter::Config::api_host)
+    assert_equal("./test/tmp/carterdte_smtp_filter.log", CarterdteSmtpFilter::Config::log_file)
+  end
+  
+end

data/test/test_dte.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class TestDte < Minitest::Test
+  
+  def setup
+    @resultado = File.open("./test/fixtures/acuse.xml", "rb")
+    @envio = File.open("./test/fixtures/envio_dte_33.xml", "rb")
+    @dte_resultado = CarterdteSmtpFilter::Dte.new @resultado
+    @dte_envio = CarterdteSmtpFilter::Dte.new @envio
+  end
+  
+  def teardown
+    
+  end
+  
+  def test_should_only_parse_valid_dtes
+    file = File.open("./test/fixtures/invalid_dte.xml", "rb")
+    dte = CarterdteSmtpFilter::Dte.new file
+    assert(!dte.valid?, "Should be false")
+    assert(@dte_resultado.valid?, "Failure message.")
+    assert(@dte_envio.valid?, "Failure message.")
+  end
+  
+  def test_root_should_return_the_root_element
+    assert_equal("Resultado", @dte_resultado.root_name)
+    assert_equal("SetDTE", @dte_envio.root_name)
+  end
+  
+  def test_return_msg_type
+    assert_equal("respuesta", @dte_resultado.msg_type)
+    assert_equal("envio", @dte_envio.msg_type)
+  end
+  
+  def test_return_setdte_id
+    assert_equal("SETDTE94528000X33X7597817X94141763", @dte_resultado.setdte_id)
+    assert_equal("SETDTE96529310X33X3152118X94141243", @dte_envio.setdte_id)
+  end
+  
+  def test_rut_emisor
+    assert_equal("94528000-K", @dte_resultado.rut_emisor)
+    assert_equal("96529310-8", @dte_envio.rut_emisor)
+  end
+  
+  def test_rut_receptor
+    assert_equal("81537600-5", @dte_resultado.rut_receptor)
+    assert_equal("81201000-K", @dte_envio.rut_receptor)
+  end
+  
+  def test_dte_type
+    assert_equal("33", @dte_resultado.dte_type)
+    assert_equal("33", @dte_envio.dte_type)
+  end
+  
+  def test_dte_fecha_emision
+    date_envio = Time.parse("2015-05-09T11:10:10").to_date
+    date_resultado = Time.parse("2015-05-09T12:30:11").to_date
+    assert_equal(date_resultado, @dte_resultado.fecha_emision)
+    assert_equal(date_envio, @dte_envio.fecha_emision)
+  end
+  
+  def test_dte_fecha_recepcion
+    date_resultado = Time.parse("2015-05-09T12:30:11").to_date
+    assert_equal(date_resultado, @dte_resultado.fecha_recepcion)
+    assert_equal(nil, @dte_envio.fecha_recepcion)
+  end
+  
+  def test_return_empty_json_if_no_valid
+    file = File.open("./test/fixtures/invalid_dte.xml", "rb")
+    dte = CarterdteSmtpFilter::Dte.new file
+    json = JSON.parse dte.to_json
+    assert_equal({}, json)
+  end
+  
+  def test_return_json_object
+    json = JSON.parse @dte_resultado.to_json
+    assert_equal("81537600-5", json["rut_receptor"])
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,277 @@
+require "carterdte_smtp_filter"
+require 'pp'
+require 'time'
+require 'date'
+
+require 'minitest/autorun'
+require 'minitest/reporters' # requires the gem
+require 'webmock/minitest'
+
+require 'fake_api'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new # spec-like progress
+
+# Only log Celluloid errors
+#Celluloid.logger.level = Logger::ERROR
+
+
+#CarterDteSmtp::Config.parse("./test/fixtures/config.yml")
+
+def check_imap()
+  require "mail"
+  Mail.defaults do
+    retriever_method :imap, address: "localhost", port: 143,  user_name: "carterdte", password: "123456"
+  end
+  
+  emails = Mail.find keys: ['NOT', 'SEEN']
+  emails.first
+  
+end
+
+class Enviacorreo  
+  attr_accessor :to, :from, :body, :subject, :attachment_path, :server, :port
+  
+  def initialize(to: "carterdte@example.com", from: "dte@itlinux.cl", body: "Cuerpo correo", subject: "DTE", attachment_path: false, server: "localhost", port: 2025)
+    @to = to
+    @from = from
+    @body = body
+    @subject = subject
+    @attachment_path = attachment_path
+    @server = server
+    @port = port
+  end
+  
+  def send
+    message.deliver!
+  end
+  
+  def message
+    smtp_conn = smtp_options
+    Mail.defaults do
+      delivery_method :smtp_connection, { :connection => smtp_conn.start }
+    end
+    mail = Mail.new(
+       from:     @from,
+       to:       @to,
+       subject:  @subject,
+       body:     @body
+    )
+    mail.add_file @attachment_path if @attachment_path
+    mail
+  end
+  
+  def smtp_options
+    smtp = Net::SMTP.new(@server, @port)
+    smtp.read_timeout = 2
+    smtp.open_timeout = 2
+    smtp
+  end
+  
+end
+
+class ReturnSmtp < MidiSmtpServer::Smtpd
+
+  attr_accessor :mail
+
+  def start
+    @logger = Logger.new('/dev/null')
+    @port = CarterdteSmtpFilter::Config::return_port
+    @host = CarterdteSmtpFilter::Config::return_host
+    super
+  end
+
+  def on_message_data_event(ctx)
+    File.open("./test/tmp/returnmail", "w") {|file| file.write ctx[:message][:data]}
+  end
+  
+  def process_line(line)
+        # check wether in data or command mode
+        if Thread.current[:cmd_sequence] != :CMD_DATA
+
+          # Handle specific messages from the client
+          case line
+        
+          when (/^(HELO|EHLO)(\s+.*)?$/i)
+            # HELO/EHLO
+            # 250 Requested mail action okay, completed
+            # 421 <domain> Service not available, closing transmission channel
+            # 500 Syntax error, command unrecognised
+            # 501 Syntax error in parameters or arguments
+            # 504 Command parameter not implemented
+            # 521 <domain> does not accept mail [rfc1846]
+            # ---------
+            # check valid command sequence
+            raise Smtpd503Exception if Thread.current[:cmd_sequence] != :CMD_HELO
+            # handle command
+            @cmd_data = line.gsub(/^(HELO|EHLO)\ /i, '').strip
+            # call event to handle data
+            on_helo_event(Thread.current[:ctx], @cmd_data)
+            # if no error raised, append to message hash
+            Thread.current[:ctx][:server][:helo] = @cmd_data
+            # set sequence state as RSET
+            Thread.current[:cmd_sequence] = :CMD_RSET
+            # reply ok
+            return "250 OK"
+
+          when (/^NOOP\s*$/i)
+            # NOOP
+            # 250 Requested mail action okay, completed
+            # 421 <domain> Service not available, closing transmission channel
+            # 500 Syntax error, command unrecognised
+            return "250 OK"
+        
+          when (/^RSET\s*$/i)
+            # RSET
+            # 250 Requested mail action okay, completed
+            # 421 <domain> Service not available, closing transmission channel
+            # 500 Syntax error, command unrecognised
+            # 501 Syntax error in parameters or arguments
+            # ---------
+            # check valid command sequence
+            raise Smtpd503Exception if Thread.current[:cmd_sequence] == :CMD_HELO
+            # handle command
+            reset_ctx
+            return "250 OK"
+        
+          when (/^QUIT\s*$/i)
+            # QUIT
+            # 221 <domain> Service closing transmission channel
+            # 500 Syntax error, command unrecognised
+            Thread.current[:cmd_sequence] = :CMD_QUIT
+            return ""
+        
+          when (/^MAIL FROM\:/i)
+            # MAIL
+            # 250 Requested mail action okay, completed
+            # 421 <domain> Service not available, closing transmission channel
+            # 451 Requested action aborted: local error in processing
+            # 452 Requested action not taken: insufficient system storage
+            # 500 Syntax error, command unrecognised
+            # 501 Syntax error in parameters or arguments
+            # 552 Requested mail action aborted: exceeded storage allocation
+            # ---------
+            # check valid command sequence
+            raise Smtpd503Exception if Thread.current[:cmd_sequence] != :CMD_RSET
+            # handle command
+            @cmd_data = line.gsub(/^MAIL FROM\:/i, '').strip
+            # call event to handle data
+            if return_value = on_mail_from_event(Thread.current[:ctx], @cmd_data)
+              # overwrite data with returned value
+              @cmd_data = return_value
+            end
+            # if no error raised, append to message hash
+            Thread.current[:ctx][:envelope][:from] = @cmd_data
+            # set sequence state
+            Thread.current[:cmd_sequence] = :CMD_MAIL
+            # reply ok
+            return "250 OK"
+        
+          when (/^RCPT TO\:/i)
+            # RCPT
+            # 250 Requested mail action okay, completed
+            # 251 User not local; will forward to <forward-path>
+            # 421 <domain> Service not available, closing transmission channel
+            # 450 Requested mail action not taken: mailbox unavailable
+            # 451 Requested action aborted: local error in processing
+            # 452 Requested action not taken: insufficient system storage
+            # 500 Syntax error, command unrecognised
+            # 501 Syntax error in parameters or arguments
+            # 503 Bad sequence of commands
+            # 521 <domain> does not accept mail [rfc1846]
+            # 550 Requested action not taken: mailbox unavailable
+            # 551 User not local; please try <forward-path>
+            # 552 Requested mail action aborted: exceeded storage allocation
+            # 553 Requested action not taken: mailbox name not allowed
+            # ---------
+            # check valid command sequence
+            raise Smtpd503Exception if ![ :CMD_MAIL, :CMD_RCPT ].include?(Thread.current[:cmd_sequence])
+            # handle command
+            @cmd_data = line.gsub(/^RCPT TO\:/i, '').strip
+            # call event to handle data
+            if return_value = on_rcpt_to_event(Thread.current[:ctx], @cmd_data)
+              # overwrite data with returned value
+              @cmd_data = return_value
+            end
+            # if no error raised, append to message hash
+            Thread.current[:ctx][:envelope][:to] << @cmd_data
+            # set sequence state
+            Thread.current[:cmd_sequence] = :CMD_RCPT
+            # reply ok
+            return "250 OK"
+        
+          when (/^DATA\s*$/i)
+            # DATA
+            # 354 Start mail input; end with <CRLF>.<CRLF>
+            # 250 Requested mail action okay, completed
+            # 421 <domain> Service not available, closing transmission channel received data
+            # 451 Requested action aborted: local error in processing
+            # 452 Requested action not taken: insufficient system storage
+            # 500 Syntax error, command unrecognised
+            # 501 Syntax error in parameters or arguments
+            # 503 Bad sequence of commands
+            # 552 Requested mail action aborted: exceeded storage allocation
+            # 554 Transaction failed
+            # ---------
+            # check valid command sequence
+            raise Smtpd503Exception if Thread.current[:cmd_sequence] != :CMD_RCPT
+            # handle command
+            # set sequence state
+            Thread.current[:cmd_sequence] = :CMD_DATA
+            # reply ok / proceed with message data
+            return "354 Enter message, ending with \".\" on a line by itself"
+        
+          else
+            # If we somehow get to this point then
+            # we have encountered an error
+            raise Smtpd500Exception
+
+        end
+        
+        else
+          # If we are in data mode and the entire message consists
+          # solely of a period on a line by itself then we
+          # are being told to exit data mode
+          if (line.chomp =~ /^\.$/)
+            # append last chars to message data
+            Thread.current[:ctx][:message][:data] += line
+            # remove ending line .
+            Thread.current[:ctx][:message][:data].gsub!(/\r\n\Z/, '').gsub!(/\.\Z/, '')
+            # save delivered time
+            Thread.current[:ctx][:message][:delivered] = Time.now.utc
+            # save bytesize of message data
+            Thread.current[:ctx][:message][:bytesize] = Thread.current[:ctx][:message][:data].bytesize
+            # call event
+            begin
+              on_message_data_event(Thread.current[:ctx])
+              array = (0..9).to_a + ("A".."F").to_a
+              return "250 2.0.0 Ok: queued as #{array.sample(11).join("")}"
+          
+            # test for SmtpdException 
+            rescue SmtpdException
+              # just re-raise exception set by app
+              raise
+          
+            # test all other Exceptions
+            rescue Exception => e
+              # send correct aborted message to smtp dialog
+              raise Smtpd451Exception.new("#{e}")
+
+            ensure
+              # always start with empty values after finishing incoming message
+              # and rset command sequence
+              reset_ctx
+            end
+        
+          else
+            # If we are in date mode then we need to add
+            # the new data to the message
+            Thread.current[:ctx][:message][:data] += line
+            return ""
+            # command sequence state will stay on :CMD_DATA
+
+          end
+
+        end
+      end
+
+end

data/test/test_message.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class TestMessage < Minitest::Test
+  
+  def setup
+    CarterdteSmtpFilter::Config.parse("./test/fixtures/config.yml")
+    @server = CarterdteSmtpFilter::SmtpServer.new()
+    @server.start
+    @return_stmp = ReturnSmtp.new()
+    @return_stmp.start
+  end
+  
+  def teardown
+    @server.shutdown
+    sleep 2 unless @server.connections == 0
+    @server.stop
+    @return_stmp.shutdown
+    @return_stmp.stop
+  end
+  
+  def test_message_should_save_server_response_when_returning_email
+    raw_mail = File.open("./test/fixtures/mail.tmp", "rb").read
+    message = CarterdteSmtpFilter::Message.new raw_mail
+    response = message.return_email
+    assert(Net::SMTP::Response == message.response.class, "Response should be a SMTP Response")
+  end
+  
+  def test_message_should_save_server_queueid_response_if_any
+    raw_mail = File.open("./test/fixtures/mail_with_dte.eml", "rb").read
+    message = CarterdteSmtpFilter::Message.new raw_mail
+    message.process
+    assert_equal(message.response.string.split(/\s+/).last, message.qid)  
+  end
+  
+  def test_message_to_json_should_return_json_object_with_message_metada
+    message = CarterdteSmtpFilter::Message.new File.open("./test/fixtures/mail_with_dte.eml", "rb").read
+    assert(JSON.parse(message.to_json), "No JSON")
+    json = JSON.parse(message.to_json)
+    assert_equal(message.email.to, json["to"])
+    assert_equal(message.email.from, json["from"])
+    assert_equal(message.email.date.to_s, json["date"])
+    assert_equal("96529310-8", json["dte"]["rut_emisor"])
+  end
+
+  def test_extract_dte_should_return_false_if_no_attachments
+    message = CarterdteSmtpFilter::Message.new File.open("./test/fixtures/mail.tmp", "rb").read
+    assert(!message.extract_dte, "Failure message.")
+  end
+  
+  def test_extract_dte_should_return_false_if_no_dte_attachments
+    message = CarterdteSmtpFilter::Message.new File.open("./test/fixtures/email_with_attachment_no_dte.eml", "rb").read
+    assert(!message.extract_dte, "Failure message.")
+  end
+  
+  def test_extract_dte_should_return_mail_part_with_xml_file
+    message = CarterdteSmtpFilter::Message.new File.open("./test/fixtures/mail_with_multiple_attachments.eml", "rb").read
+    assert(message.dte, "Failure message.")
+  end
+
+  
+  def test_message_dte_should_be_a_dte_object
+    message = CarterdteSmtpFilter::Message.new File.open("./test/fixtures/mail_with_dte.eml", "rb").read
+    assert_equal(CarterdteSmtpFilter::Dte, message.dte.class)
+  end
+  
+    
+end