howitzer 1.0.1 → 1.0.2

data/lib/howitzer/utils/email/mailgun.rb

@@ -1,175 +0,0 @@
-#For details, please see https://github.com/mailgun/mailgun.rb or https://github.com/hardikshah/mailgun.rb
-#Modified from original adding rest-client 'remove'
-require 'active_resource'
-require 'rest-client'
-
-class Mailgun
-
-  # Initializes Mailgun API
-  # Must be called before any other method
-  #
-  # Parameters:
-  # api_key - Your API key
-  # api_url - API base URL
-  #
-  def self.init(api_key, api_url = "https://mailgun.net/api/")
-    MailgunResource.password = api_key
-    api_url = api_url.gsub(/\/$/, '') + "/"
-    MailgunResource.site = api_url
-  end
-
-  # This is a patch of private ActiveResource method.
-  # It takes HTTPResponse and raise AR-like error if response code is not 2xx
-  def self.handle_response(response)
-    case response.code.to_i
-      when 301,302
-        raise(Redirection.new(response))
-      when 200...400
-        response
-      when 400
-        raise(ActiveResource::BadRequest.new(response))
-      when 401
-        raise(ActiveResource::UnauthorizedAccess.new(response))
-      when 403
-        raise(ActiveResource::ForbiddenAccess.new(response))
-      when 404
-        raise(ActiveResource::ResourceNotFound.new(response))
-      when 405
-        raise(ActiveResource::MethodNotAllowed.new(response))
-      when 409
-        raise(ActiveResource::ResourceConflict.new(response))
-      when 410
-        raise(ActiveResource::ResourceGone.new(response))
-      when 422
-        raise(ActiveResource::ResourceInvalid.new(response))
-      when 401...500
-        raise(ActiveResource::ClientError.new(response))
-      when 500...600
-        raise(ActiveResource::ServerError.new(response))
-      else
-        raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
-    end
-  end
-
-  module RequestBuilder
-    def prepare_request(url_string)
-      uri = URI.parse(url_string)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true if uri.port == 443
-      return [http, (uri.path + '?' + uri.query)]
-    end
-  end
-end
-
-class MailgunMessage
-  extend Mailgun::RequestBuilder
-
-  MAILGUN_TAG = 'X-Mailgun-Tag'
-
-  # Sends a MIME-formatted message
-  #
-  # raw_mime =
-  # "Content-Type: text/plain;charset=utf-8\n" +
-  # "From: me@host\n" +
-  # "To: you@host\n" +
-  # "Subject: Hello!\n\n" +
-  # "Body"
-  # MailgunMessage::send_raw("me@host", "you@host", raw_mime)
-  #
-  def self.send_raw(sender, recipients, raw_body, servername='')
-    uri_str = "#{MailgunResource.site}messages.eml?api_key=#{MailgunResource.password}&servername=#{servername}"
-    http, url = prepare_request(uri_str)
-    data = "#{sender}\n#{recipients}\n\n#{raw_body}"
-    res = http.post(url, data, {"Content-type" => "text/plain" })
-    Mailgun::handle_response(res)
-  end
-
-  # Sends a plain-text message
-  #
-  # MailgunMessage::send_text("me@host.com",
-  # "you@host.com",
-  # "Subject",
-  # "Hi!\nThis is message body")
-  #
-  def self.send_text(sender, recipients, subject, text, servername='', options = nil)
-    uri_str = "#{MailgunResource.site}messages.txt?api_key=#{MailgunResource.password}&servername=#{servername}"
-    params = { :sender => sender, :recipients => recipients, :subject => subject, :body => text}
-    unless options.nil?
-      params['options'] = ActiveSupport::JSON.encode(options)
-    end
-    http, url = prepare_request(uri_str)
-    req = Net::HTTP::Post.new(url)
-    req.set_form_data(params)
-    res = http.request(req)
-    Mailgun::handle_response(res)
-  end
-end
-
-# Base class for Mailgun resource classes
-# It adds upsert() method on top of ActiveResource::Base
-#
-class MailgunResource < ActiveResource::Base
-  self.user = "api_key"
-  extend Mailgun::RequestBuilder
-
-  # Create new resource or update it if resource already exist.
-  # There are 2 differences between upsert() and save():
-  # - Upsert does not raise an exception if a resource already exist.
-  # - Upsert does not return the id of freshly inserted resource
-  #
-  # >> route = Route.new
-  # >> route.pattern = '*@mydomain.com'
-  # >> route.destination = 'http://mydomain.com/addcomment'
-  # >> route.upsert()
-  #
-  def upsert()
-    self.class.post('upsert', {}, self.to_xml())
-  end
-end
-
-# All mail arriving to emails addresses that have mailboxes associated
-# will be stored on the server and can be later accessed via IMAP or POP3
-# protocols.
-#
-# Mailbox has several properties:
-#
-# alex@gmail.com
-# ^ ^
-# | |
-# user domain
-#
-class Mailbox < MailgunResource
-  # Example of a CSV file:
-  #
-  # john@domain.com, password
-  # doe@domain.com, password2
-  #
-  def self.upsert_from_csv(mailboxes)
-    uri_str = "#{MailgunResource.site}mailboxes.txt?api_key=#{MailgunResource.password}"
-    http, url = prepare_request(uri_str)
-    res = http.post(url, mailboxes, {"Content-type" => "text/plain" })
-    Mailgun::handle_response(res)
-  end
-
-  def self.remove(mailbox)
-    res = RestClient.delete "https://api:#{MailgunResource.password}"\
-    "@api.mailgun.net/v2/#{mailbox.domain}/mailboxes/#{mailbox.user}"
-    Mailgun::handle_response(res)
-  end
-end
-
-
-# This class represents Mailgun route.
-# A route has 2 properties: pattern and destination
-#
-# Examples of patterns:
-# - '*' - match all
-# - exact match (foo@bar.com)
-# - domain pattern, i.e. a pattern like "@example.com" - it will match all emails going to example.com
-# - any regular expression
-#
-# Destination can be one of:
-# - an emails address to forward to
-# - a URL for HTTP POST
-class Route < MailgunResource
-end

data/lib/howitzer/utils/email/mailgun_helper.rb

@@ -1,61 +0,0 @@
-module MailgunHelper
-
-  ##
-  #
-  # Creates new mailbox for given user_name
-  #
-  # *Parameters:*
-  # * +user_name+ - user name
-  # * +domain+ - domain (default to: settings.mail_pop3_domain )
-  # * +password+ - password (default to: settings.mail_pop3_user_pass )
-  #
-
-
-  def create_mailbox(user_name,
-                     domain=settings.mail_pop3_domain,
-                     password=settings.mail_pop3_user_pass)
-    log.info "Create '#{user_name}@#{domain}' mailbox"
-    mbox = Mailbox.new(:user => user_name, :domain => domain, :password => password)
-    mbox.upsert()
-    mbox
-  end
-
-  ##
-  #
-  # Deletes given mailbox
-  #
-  # *Parameters:*
-  # * +mailbox+ - mailbox to delete
-  #
-
-  def delete_mailbox(mailbox)
-    log.info "Delete '#{mailbox.user}@#{mailbox.domain}' mailbox"
-    begin
-      Mailbox.remove(mailbox)
-    rescue Exception => e
-      log.warn "Unable to delete '#{mailbox.user}' mailbox: #{e.message}"
-    end
-  end
-
-  ##
-  #
-  # Deletes all mailboxes except those in exceptions
-  #
-  # *Parameters:*
-  # * +exceptions+ - list of email addresses
-  #
-
-  def delete_all_mailboxes(*exceptions)
-    exceptions += ["postmaster@#{settings.mail_smtp_domain}"] #system and default mailbox
-    exceptions = exceptions.uniq
-    log.info "Delete all mailboxes except: #{exceptions.map(&:inspect).join(', ')}"
-    i = 0
-    Mailbox.find(:all).each do |m|
-      next if exceptions.include?("#{m.user}@#{m.domain}")
-      Mailbox.delete(m.id)
-      i += 1
-    end
-
-    log.info "Were deleted '#{i}' mailboxes"
-  end
-end

data/spec/unit/bin/howitzer_spec.rb

@@ -1,175 +0,0 @@
-require "spec_helper"
-load "bin/howitzer"
-
-HELP_MESSAGE = %{
-howitzer [command {--cucumber, --rspec}] | {options}
-
-Commands are ...
-    install                  Generate test framework units:
-          --rspec                add RSpec integration with framework
-          --cucumber             add Cucumber integration with framework
-Options are ...
-    --help                   Display this help message.
-    --version                Display the program version.
-  }
-
-shared_examples "check argument" do |arg|
-  before do
-    stub_const("ARGV", [arg])
-    expect(self).to_not receive(:puts)
-    expect(self).to_not receive(:exit)
-  end
-  context "(#{arg})" do
-    let(:arg) { arg }
-    it { expect(subject).to be_nil }
-  end
-end
-
-describe Howitzer do
-  describe "#check_arguments" do
-    subject { check_arguments }
-    context "when right arguments specified" do
-      it_behaves_like "check argument", 'install --cucumber'
-      it_behaves_like "check argument", 'install --rspec'
-      it_behaves_like "check argument", 'install --cucumber --rspec'
-      it_behaves_like "check argument", 'install --rspec --cucumber'
-      it_behaves_like "check argument", '--version'
-      it_behaves_like "check argument", '--help'
-      it_behaves_like "check argument", '--HELP'
-    end
-    context "when arguments incorrect" do
-      before do
-        expect(self).to receive(:puts).with("ERROR: incorrect options. Please, see help for details").once
-        expect(self).to receive(:puts).with(HELP_MESSAGE)
-        expect(self).to receive(:exit).with(1)
-      end
-      context "(missing arguments)" do
-        it { expect(subject).to be_nil  }
-      end
-      context "UNKNOWN argument" do
-        let(:arg) { '--unknown' }
-        before { stub_const("ARGV", [arg]) }
-        it { expect(subject).to be_nil }
-      end
-    end
-  end
-
-  describe "#parse_options" do
-    subject { parse_options }
-    context "when correct argument received" do
-      before do
-        stub_const("ARGV", arg)
-        expect(self).not_to receive(:puts).with("ERROR: incorrect first argument '#{arg}'")
-      end
-      context "'--version' argument given" do
-        let(:arg) { ['--version'] }
-      before{ stub_const("Howitzer::VERSION", '1.0.0') }
-        it do
-          expect(self).to receive(:exit).with(0).once
-          expect(self).to receive(:puts).with("Version: 1.0.0")
-          subject
-        end
-      end
-      context "'--help' argument given" do
-        let(:arg) { ['--help'] }
-        it do
-          expect(self).to receive(:puts).with(HELP_MESSAGE)
-          subject
-        end
-      end
-      context "'install' argument" do
-        let(:primary_arg) { 'install' }
-        let(:generator) { double('generator') }
-        before do
-          expect(Howitzer::ConfigGenerator).to receive(:new)
-          expect(Howitzer::PagesGenerator).to receive(:new)
-          expect(Howitzer::TasksGenerator).to receive(:new)
-          expect(Howitzer::EmailsGenerator).to receive(:new)
-          expect(Howitzer::RootGenerator).to receive(:new)
-          expect(self).not_to receive(:puts).with("ERROR: Empty option specified.")
-          expect(self).not_to receive(:puts).with("ERROR: Unknown option specified.")
-          expect(self).not_to receive(:puts).with(HELP_MESSAGE)
-        end
-        context "with option '--cucumber'" do
-          let(:arg) { [primary_arg, '--cucumber'] }
-          it do
-            expect(Howitzer::RspecGenerator).to_not receive(:new)
-            expect(Howitzer::CucumberGenerator).to receive(:new)
-            subject
-           end
-        end
-        context "with option '--rspec'" do
-          let(:arg) {[primary_arg, '--rspec']}
-          it do
-            expect(Howitzer::RspecGenerator).to receive(:new)
-            expect(Howitzer::CucumberGenerator).to_not receive(:new)
-            subject
-          end
-        end
-      end
-    end
-    context "when incorrect arguments received" do
-      before { stub_const("ARGV", arg) }
-      context "with (missing) argument" do
-        let(:arg) {[]}
-        it do
-          expect(self).to receive(:puts).with("ERROR: incorrect first argument ('')")
-          expect(self).to receive(:puts).with(HELP_MESSAGE)
-          expect(self).to receive(:exit).with(1)
-          subject
-        end
-      end
-      context "with UNKNOWN argument" do
-        let(:arg) {['unknown']}
-        it do
-          expect(self).to receive(:puts).with("ERROR: incorrect first argument ('unknown')")
-          expect(self).to receive(:puts).with(HELP_MESSAGE)
-          expect(self).to receive(:exit).with(1)
-          subject
-        end
-      end
-    end
-
-    context "when 'install' option received with incorrect arguments" do
-      let(:primary_arg) { 'install' }
-      let(:generator) { double('generator') }
-      before { stub_const("ARGV", arg) }
-      context "with UNKNOWN option specified" do
-        let(:arg) {[primary_arg, '--unknown']}
-        before do
-          expect(Howitzer::ConfigGenerator).to_not receive(:new)
-          expect(Howitzer::PagesGenerator).to_not receive(:new)
-          expect(Howitzer::TasksGenerator).to_not receive(:new)
-          expect(Howitzer::EmailsGenerator).to_not receive(:new)
-          expect(Howitzer::RootGenerator).to_not receive(:new)
-          expect(Howitzer::RspecGenerator).to_not receive(:new)
-          expect(Howitzer::CucumberGenerator).to_not receive(:new)
-        end
-        it do
-          expect(self).to receive(:puts).with("ERROR: Unknown '--unknown' option specified.")
-          expect(self).to receive(:puts).with(HELP_MESSAGE)
-          expect(self).to receive(:exit).with(1)
-          subject
-        end
-      end
-      context "with no option specified" do
-        let(:arg) {[primary_arg]}
-        before do
-          expect(Howitzer::ConfigGenerator).to_not receive(:new)
-          expect(Howitzer::PagesGenerator).to_not receive(:new)
-          expect(Howitzer::TasksGenerator).to_not receive(:new)
-          expect(Howitzer::EmailsGenerator).to_not receive(:new)
-          expect(Howitzer::RootGenerator).to_not receive(:new)
-          expect(Howitzer::RspecGenerator).to_not receive(:new)
-          expect(Howitzer::CucumberGenerator).to_not receive(:new)
-        end
-        it do
-          expect(self).to receive(:puts).with("ERROR: No option specified for install command.")
-          expect(self).to receive(:puts).with(HELP_MESSAGE)
-          expect(self).to receive(:exit).with(1)
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/unit/lib/utils/email/email_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-require "#{lib_path}/howitzer/utils/log"
-require "#{lib_path}/howitzer/utils/email/email"
-
-
-describe Email do
-  let(:message) { double }
-  let(:message_subject) { 'test_subject' }
-  let(:mail_address) { double }
-  let(:recipient) { 'vasya@test.com' }
-  let(:email_object) { Email.new(message) }
-  before do
-    stub_const("Email::SUBJECT", 'test_subject')
-    stub_const("::Mail::Address", mail_address)
-    allow(mail_address).to receive(:new).with(recipient).and_return(mail_address)
-    allow(message).to receive(:to).and_return([recipient])
-  end
-
-  describe "#new" do
-    subject { Email.new(message) }
-    before { allow(message).to receive(:subject).and_return('test_subject') }
-    context "when subject is the same" do
-      it { expect(subject.instance_variable_get(:@recipient_address)).to eql(mail_address) }
-      it { expect(subject.instance_variable_get(:@message)).to eql(message) }
-    end
-  end
-
-  describe ".find_by_recipient" do
-    subject { Email.find_by_recipient(recipient) }
-    context "when 'recipient' specified " do
-      before { expect(Email).to receive(:find).with(recipient, 'test_subject').and_return(true).once }
-      it { expect(subject).to be_true }
-    end
-    context "when 'recipient' not specified " do
-      let(:recipient) { nil }
-      before { expect(Email).to receive(:find).with(recipient,'test_subject').and_return(nil).once }
-      it { expect(subject).to be_nil }
-    end
-  end
-
-  describe ".find" do
-    let(:mail_client) { double }
-    subject { Email.find('Vasya', 'Text') }
-    before  do
-      stub_const("MailClient", double)
-      allow(MailClient).to receive(:by_email).and_return(mail_client)
-      allow(mail_client).to receive(:find_mail).and_return(messages )
-      allow(message).to receive(:subject).and_return('test_subject')
-    end
-    context "when messages.first present"  do
-      let(:messages) { [message] }
-      it {expect(subject).to be_kind_of(Email) }
-    end
-
-    context "when messages.first not present" do
-      let(:messages) {[]}
-      it do
-        expect(log).to receive(:error).with("Email was not found (recipient: 'Vasya')").once
-        subject
-      end
-    end
-  end
-
-  describe "#plain_text_body" do
-    subject { email_object.plain_text_body }
-    let(:email_object) { Email.new(message) }
-    let(:mime_part) { double }
-    before do
-      allow(message).to receive(:subject).and_return('test_subject')
-      expect(mime_part).to receive(:to_s).and_return('test_string')
-      expect(email_object).to receive(:get_mime_part).with(message, 'text/plain').and_return(mime_part)
-    end
-    it { expect(subject).to eql('test_string') }
-  end
-end