howitzer 0.0.3 → 1.0.1

data/spec/unit/lib/init_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/data_generator/gen.rb"
+require 'capybara/dsl'
+
+describe "Helpers" do
+  before do
+    stub_const("Mailgun", double)
+    expect(settings).to receive(:mailgun_api_key){ 'some_api' }
+  end
+  it "should init Mailgun and include modules" do
+    expect(Mailgun).to receive(:init).with('some_api').once
+    require "#{lib_path}/howitzer/init.rb"
+  end
+end

data/spec/unit/lib/settings_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "Settings" do
+  context "#settings" do
+    subject { settings }
+    context "when method called two times" do
+      let(:other_settings) { settings }
+      it { expect(subject).to equal(other_settings) }
+      it { expect(other_settings).to be_a_kind_of(SexySettings::Base) }
+    end
+  end
+  context "SexySettings configuration" do
+    subject { SexySettings.configuration }
+    it { expect(subject.path_to_custom_settings).to include('config/custom.yml') }
+    it { expect(subject.path_to_default_settings).to include('config/default.yml') }
+  end
+end

data/spec/unit/lib/utils/data_generator/data_storage_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/data_generator/data_storage"
+
+describe "DataGenerator" do
+  describe "DataStorage" do
+    describe ".store" do
+      subject { DataGenerator::DataStorage.store(ns, 7, :halt) }
+      context "when namespace specified" do
+        let(:ns) { :user }
+        it "should return value" do
+          expect(subject).to eql(:halt)
+        end
+        it "should store namespace value" do
+          adata = DataGenerator::DataStorage.instance_variable_get(:@data)
+          expect(adata[:user]).to eql({7 => :halt})
+        end
+      end
+      context "when namespace empty" do
+        let(:ns) { nil }
+        it { expect {subject}.to raise_error(RuntimeError, "Data storage namespace can not be empty") }
+      end
+    end
+    describe ".extract" do
+      subject { DataGenerator::DataStorage.extract(ns, key) }
+      before { DataGenerator::DataStorage.instance_variable_set(:@data, {user: {7 => :exit}}) }
+      describe "when namespace specified" do
+        let(:ns) { :user }
+        context "and namespace key found" do
+          let(:key) { 7 }
+          it { expect(subject).to eql(:exit) }
+        end
+        context "and namespace key not found" do
+          let(:key) { 5 }
+          it { expect(subject).to be_nil }
+        end
+        context "but namespace key not specified" do
+          let(:key) { nil }
+          it { expect(subject).to eql({ 7 => :exit }) }
+        end
+      end
+      context "when namespace not found" do
+        let(:ns) { :guest }
+        let(:key) { 11 }
+        it { expect(subject).to be_nil }
+      end
+      context "when namespace not specified" do
+        let(:ns) { nil }
+        let(:key) { nil }
+        it { expect {subject}.to raise_error(RuntimeError, "Data storage namespace can not be empty") }
+      end
+    end
+    describe ".clear_ns" do
+      subject { DataGenerator::DataStorage.clear_ns(:user) }
+      before { DataGenerator::DataStorage.instance_variable_set(:@data, {user: {7 => :exit}}) }
+      it "should return empty hash" do
+        subject
+        adata = DataGenerator::DataStorage.instance_variable_get(:@data)
+        expect(adata[:user]).to eql({})
+      end
+    end
+  end
+end

data/spec/unit/lib/utils/data_generator/gen_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/data_generator/gen"
+
+describe "DataGenerator" do
+  describe "Gen" do
+    describe ".user" do
+      subject { DataGenerator::Gen.user(params) }
+      before do
+        allow(settings).to receive(:def_test_pass) { 'test_pass' }
+        allow(settings).to receive(:mail_pop3_domain) { 'mail.com' }
+        allow(DataGenerator::Gen).to receive(:serial) { '012345678abcde' }
+      end
+      context "when params specified" do
+        let(:params) { { login: 'alex', password: 'pa$$w0rd', mailbox: 'member@test.com' } }
+        it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        it { expect(subject.email).to eql 'u012345678abcde@mail.com' }
+        it do
+          email_nm = subject.instance_variable_get(:@email_name)
+          expect(email_nm).to eql 'u012345678abcde'
+        end
+        it { expect(subject.domain).to eql 'mail.com' }
+        it { expect(subject.login).to eql 'alex' }
+        it { expect(subject.password).to eql 'pa$$w0rd' }
+        it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
+        it { expect(subject.last_name).to eql 'LastName012345678abcde' }
+        it { expect(subject.mailbox).to eql 'member@test.com' }
+      end
+      context "with empty params" do
+        let(:params) { {} }
+        it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        it { expect(subject.email).to eql 'u012345678abcde@mail.com' }
+        it do
+          email_nm = subject.instance_variable_get(:@email_name)
+          expect(email_nm).to eql 'u012345678abcde'
+        end
+        it { expect(subject.domain).to eql 'mail.com' }
+        it { expect(subject.login).to eql 'u012345678abcde' }
+        it { expect(subject.password).to eql 'test_pass' }
+        it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
+        it { expect(subject.last_name).to eql 'LastName012345678abcde' }
+        it { expect(subject.mailbox).to be_nil }
+      end
+    end
+    describe ".given_user_by_number" do
+      subject { DataGenerator::Gen.given_user_by_number(7) }
+      before { stub_const("DataGenerator::DataStorage", double) }
+      context "when namespace key found" do
+        before { expect(DataGenerator::DataStorage).to receive(:extract).with('user', 7) { :namespace_value } }
+        it { expect(subject).to eql(:namespace_value) }
+      end
+      context "when namespace key not found" do
+        let(:dat) { :data_store }
+        before do
+          allow(DataGenerator::Gen).to receive(:user) { dat }
+          expect(DataGenerator::DataStorage).to receive(:extract).with('user', 7) { nil }
+          allow(DataGenerator::DataStorage).to receive(:store).with('user', 7, dat)
+        end
+        it { expect(subject).to eql :data_store }
+      end
+    end
+    describe ".serial" do
+      subject { DataGenerator::Gen.serial }
+      let(:ser) { 1 }
+      context "received value should conform to template" do
+        let(:ser) { subject }
+        it { expect(ser).to match /\d{9}\w{5}/ }
+      end
+      context "received values should be different" do
+        it { expect(subject).to_not eql ser }
+      end
+    end
+    describe ".delete_all_mailboxes" do
+      subject { DataGenerator::Gen.delete_all_mailboxes }
+      let(:mbox1) { double }
+      let(:mbox2) { double }
+      before do
+        stub_const("DataGenerator::DataStorage", double)
+        expect(DataGenerator::DataStorage).to receive(:extract).with('user') { { 1 => mbox1, 2 => mbox2 } }
+      end
+      it do
+        expect(mbox1).to receive(:delete_mailbox).once
+        expect(mbox2).to receive(:delete_mailbox).once
+        subject
+      end
+    end
+    describe "User" do
+      describe "#initialize" do
+        subject { DataGenerator::Gen::User.new(params) }
+        let(:params) { { email: 'alex.petrenko@mail.com', login: 'alex', password: 'pa$$w0rd',
+                         first_name: 'Alexey', last_name: 'Petrenko', mailbox: 'member@test.com' } }
+        it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        it { expect(subject.email).to eql 'alex.petrenko@mail.com' }
+        it do
+          email_nm = subject.instance_variable_get(:@email_name)
+          expect(email_nm).to eql 'alex.petrenko'
+        end
+        it { expect(subject.domain).to eql 'mail.com' }
+        it { expect(subject.login).to eql 'alex' }
+        it { expect(subject.password).to eql 'pa$$w0rd' }
+        it { expect(subject.first_name).to eql 'Alexey' }
+        it { expect(subject.last_name).to eql 'Petrenko' }
+        it { expect(subject.full_name).to eql 'Alexey Petrenko' }
+        it { expect(subject.mailbox).to eql 'member@test.com' }
+      end
+      describe "#create_mailbox" do
+        subject { nu_user.create_mailbox }
+        let(:nu_user) { DataGenerator::Gen::User.new({ email: 'alex.petrenko@mail.com', mailbox: 'member@test.com' }) }
+        before { stub_const('MailClient', double) }
+        context "should return User object" do
+          before do
+            allow(settings).to receive(:mail_pop3_domain) { 'mail.com' }
+            expect(MailClient).to receive(:create_mailbox).with('alex.petrenko').once { 'petrenko@test.com' }
+          end
+          it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        end
+        context "when mail_pop3_domain settings are equal to @domain" do
+          before do
+            allow(settings).to receive(:mail_pop3_domain) { 'mail.com' }
+            expect(MailClient).to receive(:create_mailbox).with('alex.petrenko').once { 'petrenko@test.com' }
+          end
+          it do
+            subject
+            expect(nu_user.mailbox).to eql 'petrenko@test.com'
+          end
+        end
+        context "when mail_pop3_domain settings are not equal to @domain" do
+          before { allow(settings).to receive(:mail_pop3_domain) { 'post.com' } }
+          it do
+            subject
+            expect(nu_user.mailbox).to eql 'member@test.com'
+          end
+        end
+      end
+      describe "#delete_mailbox" do
+        subject { nu_user.delete_mailbox }
+        let(:nu_user) { DataGenerator::Gen::User.new({ mailbox: mbox }) }
+        before { stub_const('MailClient', double) }
+        context "when mailbox spcified" do
+          before { expect(MailClient).to receive(:delete_mailbox).with(mbox).once { 'mailbox deleted' } }
+          let(:mbox) { 'member@test.com' }
+          it { expect(subject).to eql 'mailbox deleted' }
+        end
+        context "when mailbox not spcified" do
+          before { expect(MailClient).to_not receive(:delete_mailbox).with(mbox) }
+          let(:mbox) { nil }
+          it { expect(subject).to be_nil }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+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

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

@@ -0,0 +1,115 @@
+require "spec_helper"
+require "#{lib_path}/howitzer/utils/log"
+require "#{lib_path}/howitzer/utils/email/mail_client"
+
+describe MailClient do
+
+  describe ".default" do
+    subject { MailClient.default }
+    it do
+      expect(log).to receive(:info).with("Connect to default mailbox").once
+      expect(subject).to be_instance_of(MailClient)
+      options = {
+        smtp: {
+          address: "smtp.demo.com",
+          port: 25,
+          domain: "demo.com",
+          user_name: "test_user",
+          password: "mypass",
+          authentication: "plain",
+          enable_starttls_auto: true
+        },
+        pop3: {
+          address: "pop.demo.com",
+          port: 995,
+          user_name: "test_user",
+          password: "mypass"
+        }
+      }
+      expect(subject.instance_variable_get(:@options)).to eql(options)
+    end
+  end
+
+  describe ".by_email" do
+    subject { MailClient.by_email("vasya@gmail.com") }
+    it do
+      expect(log).to receive(:info).with("Connect to 'vasya@gmail.com' mailbox").once
+      expect(subject).to be_instance_of(MailClient)
+      options = {
+        smtp: {
+            address: "smtp.demo.com",
+            port: 25,
+            domain: "demo.com",
+            user_name: "test_user",
+            password: "mypass",
+            authentication: "plain",
+            enable_starttls_auto: true
+        },
+        pop3: {
+            address: "pop.demo.com",
+            port: 995,
+            user_name: "vasya@gmail.com",
+            password: "mypass"
+        }
+      }
+      expect(subject.instance_variable_get(:@options)).to eql(options)
+    end
+  end
+
+  describe ".merge_opts" do
+    subject { MailClient.merge_opts(*options) }
+    context "when default options" do
+      let(:expected_option) do
+        {
+             smtp: {
+                 address: "smtp.demo.com",
+                 port: 25,
+                 domain: "demo.com",
+                 user_name: "test_user",
+                 password: "mypass",
+                 authentication: "plain",
+                 enable_starttls_auto: true
+             },
+             pop3: {
+                 address: "pop.demo.com",
+                 port: 995,
+                 user_name: "test_user",
+                 password: "mypass"
+             }
+         }
+      end
+      let(:options) { [] }
+      it { expect(subject).to eql(expected_option) }
+    end
+    context "when custom options" do
+      let(:options) do
+        [{
+            smtp: {
+                address: 'fake_address',
+                port: 1123,
+                domain: 'fake_domain',
+                user_name: "fake_user_name",
+                password: "fake_password",
+                authentication: "plain",
+                enable_starttls_auto: true
+            },
+            pop3: {
+                address: "fake_address",
+                port: 999,
+                user_name: "fake_user_name",
+                password: "fake_password"
+            }
+        }]
+      end
+      it { expect(subject).to eql(options.first)}
+    end
+
+    describe "#find_mail"
+    describe "#send_mail"
+    describe "#empty_inbox"
+    describe "#start"
+    describe "constructor"
+
+  end
+
+end

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/log"
+require "#{lib_path}/howitzer/utils/email/mailgun_helper"
+
+describe MailgunHelper do
+  let(:mailgun) { double.extend MailgunHelper }
+  let(:user_name) { 'vasyapupkin' }
+  let(:settings_obj) { double }
+  let(:mbox) { double }
+  before do
+    stub_const('Mailbox', double)
+  end
+  describe "#create_mailbox" do
+    subject { mailgun.create_mailbox(user_name, *opts) }
+    before do
+      expect(log).to receive(:info).with(log_message).once
+      allow(Mailbox).to receive(:new).and_return(mbox)
+      expect(mbox).to receive(:upsert).once
+    end
+    context "when domain and password are present" do
+      let(:log_message) { "Create 'vasyapupkin@mail.ru' mailbox" }
+      let(:opts) { ['mail.ru', '123'] }
+      it { expect(subject).to eql(mbox) }
+    end
+    context "when domain and password are missed" do
+      let(:opts) { [] }
+      let(:log_message) { "Create 'vasyapupkin@test.com' mailbox" }
+      before do
+        allow(mailgun).to receive(:settings).and_return(settings_obj)
+        allow(settings_obj).to receive(:mail_pop3_domain).and_return('test.com')
+        allow(settings_obj).to receive(:mail_pop3_user_pass).and_return('test123')
+      end
+      it { expect(subject).to eql(mbox) }
+    end
+  end
+
+  describe "#delete_mailbox" do
+    subject{ mailgun.delete_mailbox(mbox)}
+    before do
+      allow(mbox).to receive(:user).and_return('vasyapupkin')
+      allow(mbox).to receive(:domain).and_return('mail.ru')
+      expect(log).to receive(:info).with("Delete 'vasyapupkin@mail.ru' mailbox").once
+    end
+    context "when successful result" do
+      before {expect(Mailbox).to receive(:remove).with(mbox).and_return(true)}
+      it { expect(subject).to be_true }
+    end
+    context "when impossible to remove mailbox" do
+      before {expect(Mailbox).to receive(:remove).with(mbox).and_raise('Test error message')}
+      it do
+        expect(log).to receive(:warn).with("Unable to delete 'vasyapupkin' mailbox: Test error message")
+        subject
+      end
+    end
+  end
+
+  describe "#delete_all_mailboxes" do
+    let(:domain) { 'mail.ru' }
+    let(:mailbox1) do
+      m = double
+      allow(m).to receive(:id).and_return(1)
+      allow(m).to receive(:user).and_return('vasyapupkin')
+      allow(m).to receive(:domain).and_return(domain)
+      m
+    end
+    let(:mailbox2) do
+      m = double
+      allow(m).to receive(:id).and_return(2)
+      allow(m).to receive(:user).and_return('postmaster')
+      allow(m).to receive(:domain).and_return(domain)
+      m
+    end
+    let(:mailbox3) do
+      m = double
+      allow(m).to receive(:id).and_return(3)
+      allow(m).to receive(:user).and_return('admin')
+      allow(m).to receive(:domain).and_return(domain)
+      m
+    end
+    let(:mail_for_exception){ 'admin@mail.ru' }
+    subject{mailgun.delete_all_mailboxes(mail_for_exception)}
+    before do
+      allow(settings).to receive(:mail_smtp_domain).and_return("mail.ru")
+      allow(Mailbox).to receive(:find).with(:all).and_return([mailbox1, mailbox2, mailbox3])
+    end
+    it do
+      expect(log).to receive(:info).with("Delete all mailboxes except: \"admin@mail.ru\", \"postmaster@mail.ru\"")
+      expect(Mailbox).to receive(:delete).with(1).once
+      expect(Mailbox).to_not receive(:delete).with(2)
+      expect(Mailbox).to_not receive(:delete).with(3)
+      expect(log).to receive(:info).with("Were deleted '1' mailboxes")
+      subject
+    end
+  end
+end